[powerpc] Full merge of PowerPC disassembler PRs, including:

* Remove dependency on capstone for PowerPC disassembly #6292
* Add support for PowerPC VLE instruction set #6740
* Add support for paired-single instructions #6821
* Various post-merge fixes and tweaks to disassembly and lifting
* Removal of dependence on capstone for assembler's scoring mechanism (capstone currently disabled, but not removed from codebase yet)

1 files changed, 2188 insertions, 0 deletions

diff --git a/arch/powerpc/decode/mnemonic.c b/arch/powerpc/decode/mnemonic.c
new file mode 100644
index 00000000..2b5fa06d
--- /dev/null
+++ b/arch/powerpc/decode/mnemonic.c
@@ -0,0 +1,2188 @@
+#include "decode.h"
+
+// the hope is to avoid having to manipulate strings in something that's
+// somewhat hot, so we create a bunch of lookup tables for each mnemonic
+
+// for "OP" and "OP."
+#define DEFINE_SUBMNEM_RC(_identifier, base)    \
+	const char* _identifier[2] =            \
+	{                                       \
+		base,                           \
+		base ".",                       \
+	};
+
+// for "OP", "OP.", "OPo", and "OPo."
+#define DEFINE_SUBMNEM_OE_RC(_identifier, base) \
+	const char* _identifier[4] =            \
+	{                                       \
+		base,                           \
+		base ".",                       \
+		base "o",                       \
+		base "o.",                      \
+	};
+
+// for "OP" and "OPl"
+#define DEFINE_SUBMNEM_LK(_identifier, base) \
+	const char* _identifier[2] =            \
+	{                                       \
+		base,                           \
+		base "l",                       \
+	};
+
+// for "OP" and "OPl" and +/- hints
+#define DEFINE_SUBMNEM_LK_HINT(_identifier, base) \
+	const char* _identifier[8] =            \
+	{                                       \
+		base,                           \
+		base "l",                       \
+		base,                           \
+		base "l",                       \
+		base "-",                       \
+		base "l-",                      \
+		base "+",                       \
+		base "l+",                      \
+	};
+
+// for "OP", "OPl", "OPa", and "OPla"
+#define DEFINE_SUBMNEM_AA_LK(_identifier, base) \
+	const char* _identifier[4] =            \
+	{                                       \
+		base,                           \
+		base "l",                       \
+		base "a",                       \
+		base "la",                      \
+	};
+
+// for "OP", "OPl", "OPa", "OPla" and +/- hints
+#define DEFINE_SUBMNEM_AA_LK_HINT(_identifier, base) \
+	const char* _identifier[16] =            \
+	{                                       \
+		base,                           \
+		base "l",                       \
+		base "a",                       \
+		base "la",                      \
+		base,                           \
+		base "l",                       \
+		base "a",                       \
+		base "la",                      \
+		base "-",                       \
+		base "l-",                      \
+		base "a-",                      \
+		base "la-",                     \
+		base "+",                       \
+		base "l+",                      \
+		base "a+",                      \
+		base "la+"                      \
+	};
+
+#define DEFINE_SUBMNEM_ROUND2ODD(_identifier, base)    \
+	const char* _identifier[2] =            \
+	{                                       \
+		base,                           \
+		base "o",                       \
+	};
+
+#define DEFINE_SUBMNEM_INEXACT(_identifier, base)    \
+	const char* _identifier[2] =            \
+	{                                       \
+		base,                           \
+		base "x",                       \
+	};
+
+DEFINE_SUBMNEM_OE_RC(SubMnemADDx, "add")
+DEFINE_SUBMNEM_OE_RC(SubMnemADDCx, "addc")
+DEFINE_SUBMNEM_OE_RC(SubMnemADDEx, "adde")
+DEFINE_SUBMNEM_OE_RC(SubMnemADDIx, "addi")
+DEFINE_SUBMNEM_RC(SubMnemADDICx, "addic")
+DEFINE_SUBMNEM_OE_RC(SubMnemADDMEx, "addme")
+DEFINE_SUBMNEM_OE_RC(SubMnemADDZEx, "addze")
+DEFINE_SUBMNEM_RC(SubMnemANDx, "and")
+DEFINE_SUBMNEM_RC(SubMnemANDCx, "andc")
+DEFINE_SUBMNEM_RC(SubMnemANDIx, "andi")
+DEFINE_SUBMNEM_AA_LK(SubMnemBx, "b")
+DEFINE_SUBMNEM_AA_LK(SubMnemBCx, "bc")
+DEFINE_SUBMNEM_LK(SubMnemBCTRx, "bctr")
+DEFINE_SUBMNEM_LK(SubMnemBCCTRx, "bcctr")
+DEFINE_SUBMNEM_LK(SubMnemBCLRx, "bclr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBDZx, "bdz")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBDZLRx, "bdzlr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBDNZx, "bdnz")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBDNZLRx, "bdnzlr")
+DEFINE_SUBMNEM_AA_LK(SubMnemBDNZFx, "bdnzf")
+DEFINE_SUBMNEM_LK(SubMnemBDNZFLRx, "bdnzflr")
+DEFINE_SUBMNEM_AA_LK(SubMnemBDNZTx, "bdnzt")
+DEFINE_SUBMNEM_LK(SubMnemBDNZTLRx, "bdnztlr")
+DEFINE_SUBMNEM_AA_LK(SubMnemBDZFx, "bdzf")
+DEFINE_SUBMNEM_LK(SubMnemBDZFLRx, "bdzflr")
+DEFINE_SUBMNEM_LK(SubMnemBDFLRx, "bdzlr")
+DEFINE_SUBMNEM_AA_LK(SubMnemBDZTx, "bdzt")
+DEFINE_SUBMNEM_LK(SubMnemBDZTLRx, "bdztlr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBEQx, "beq")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBEQCTRx, "beqctr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBEQLRx, "beqlr")
+DEFINE_SUBMNEM_AA_LK(SubMnemBFx, "bf")
+DEFINE_SUBMNEM_AA_LK(SubMnemBFLRx, "bflr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBGEx, "bge")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBGECTRx, "bgectr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBGELRx, "bgelr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBGTx, "bgt")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBGTCTRx, "bgtctr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBGTLRx, "bgtlr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBLEx, "ble")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBLECTRx, "blectr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBLELRx, "blelr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBLTx, "blt")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBLTCTRx, "bltctr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBLTLRx, "bltlr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBLRx, "blr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBNEx, "bne")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBNECTRx, "bnectr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBNELRx, "bnelr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBNSx, "bns")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBNSCTRx, "bnsctr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBNSLRx, "bnslr")
+DEFINE_SUBMNEM_AA_LK_HINT(SubMnemBSOx, "bso")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBSOCTRx, "bsoctr")
+DEFINE_SUBMNEM_LK_HINT(SubMnemBSOLRx, "bsolr")
+DEFINE_SUBMNEM_AA_LK(SubMnemBTx, "bt")
+DEFINE_SUBMNEM_AA_LK(SubMnemBTLRx, "btlr")
+DEFINE_SUBMNEM_RC(SubMnemCLRLDIx, "clrldi")
+DEFINE_SUBMNEM_RC(SubMnemCLRLWIx, "clrlwi")
+DEFINE_SUBMNEM_RC(SubMnemCLRRWIx, "clrrwi")
+DEFINE_SUBMNEM_RC(SubMnemCLRRDIx, "clrrdi")
+DEFINE_SUBMNEM_RC(SubMnemEXTLDIx, "extldi")
+DEFINE_SUBMNEM_RC(SubMnemEXTLWIx, "extlwi")
+DEFINE_SUBMNEM_RC(SubMnemEXTRWIx, "extrwi")
+DEFINE_SUBMNEM_RC(SubMnemEXTRDIx, "extrdi")
+DEFINE_SUBMNEM_RC(SubMnemCNTLZDx, "cntlzd")
+DEFINE_SUBMNEM_RC(SubMnemCNTLZWx, "cntlzw")
+DEFINE_SUBMNEM_RC(SubMnemCNTTZDx, "cnttzd")
+DEFINE_SUBMNEM_RC(SubMnemCNTTZWx, "cnttzw")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVDx, "divd")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVDEx, "divde")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVDEUx, "divdeu")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVDUx, "divdu")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVWx, "divw")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVWEx, "divwe")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVWEUx, "divweu")
+DEFINE_SUBMNEM_OE_RC(SubMnemDIVWUx, "divwu")
+DEFINE_SUBMNEM_RC(SubMnemEQVx, "eqv")
+DEFINE_SUBMNEM_RC(SubMnemEXTSBx, "extsb")
+DEFINE_SUBMNEM_RC(SubMnemEXTSHx, "extsh")
+DEFINE_SUBMNEM_RC(SubMnemEXTSWx, "extsw")
+DEFINE_SUBMNEM_RC(SubMnemEXTSWSLIx, "extswsli")
+DEFINE_SUBMNEM_RC(SubMnemFABSx, "fabs")
+DEFINE_SUBMNEM_RC(SubMnemFADDx, "fadd")
+DEFINE_SUBMNEM_RC(SubMnemFADDSx, "fadds")
+DEFINE_SUBMNEM_RC(SubMnemFCFIDx, "fcfid")
+DEFINE_SUBMNEM_RC(SubMnemFCFIDSx, "fcfids")
+DEFINE_SUBMNEM_RC(SubMnemFCFIDUx, "fcfidu")
+DEFINE_SUBMNEM_RC(SubMnemFCFIDUSx, "fcfidus")
+DEFINE_SUBMNEM_RC(SubMnemFCPSGNx, "fcpsgn")
+DEFINE_SUBMNEM_RC(SubMnemFCTIDx, "fctid")
+DEFINE_SUBMNEM_RC(SubMnemFCTIDUx, "fctidu")
+DEFINE_SUBMNEM_RC(SubMnemFCTIDUZx, "fctiduz")
+DEFINE_SUBMNEM_RC(SubMnemFCTIDZx, "fctidz")
+DEFINE_SUBMNEM_RC(SubMnemFCTIWx, "fctiw")
+DEFINE_SUBMNEM_RC(SubMnemFCTIWUx, "fctiwu")
+DEFINE_SUBMNEM_RC(SubMnemFCTIWUZx, "fctiwuz")
+DEFINE_SUBMNEM_RC(SubMnemFCTIWZx, "fctiwz")
+DEFINE_SUBMNEM_RC(SubMnemFDIVx, "fdiv")
+DEFINE_SUBMNEM_RC(SubMnemFDIVSx, "fdivs")
+DEFINE_SUBMNEM_RC(SubMnemFMADDx, "fmadd")
+DEFINE_SUBMNEM_RC(SubMnemFMADDSx, "fmadds")
+DEFINE_SUBMNEM_RC(SubMnemFMRx, "fmr")
+DEFINE_SUBMNEM_RC(SubMnemFMSUBx, "fmsub")
+DEFINE_SUBMNEM_RC(SubMnemFMSUBSx, "fmsubs")
+DEFINE_SUBMNEM_RC(SubMnemFMULx, "fmul")
+DEFINE_SUBMNEM_RC(SubMnemFMULSx, "fmuls")
+DEFINE_SUBMNEM_RC(SubMnemFNABSx, "fnabs")
+DEFINE_SUBMNEM_RC(SubMnemFNEGx, "fneg")
+DEFINE_SUBMNEM_RC(SubMnemFNMADDx, "fnmadd")
+DEFINE_SUBMNEM_RC(SubMnemFNMADDSx, "fnmadds")
+DEFINE_SUBMNEM_RC(SubMnemFNMSUBx, "fnmsub")
+DEFINE_SUBMNEM_RC(SubMnemFNMSUBSx, "fnmsubs")
+DEFINE_SUBMNEM_RC(SubMnemFREx, "fre")
+DEFINE_SUBMNEM_RC(SubMnemFRESx, "fres")
+DEFINE_SUBMNEM_RC(SubMnemFRIMx, "frim")
+DEFINE_SUBMNEM_RC(SubMnemFRINx, "frin")
+DEFINE_SUBMNEM_RC(SubMnemFRIPx, "frip")
+DEFINE_SUBMNEM_RC(SubMnemFRIZx, "friz")
+DEFINE_SUBMNEM_RC(SubMnemFRSPx, "frsp")
+DEFINE_SUBMNEM_RC(SubMnemFRSQRTEx, "frsqrte")
+DEFINE_SUBMNEM_RC(SubMnemFRSQRTESx, "frsqrtes")
+DEFINE_SUBMNEM_RC(SubMnemFSELx, "fsel")
+DEFINE_SUBMNEM_RC(SubMnemFSQRTx, "fsqrt")
+DEFINE_SUBMNEM_RC(SubMnemFSQRTSx, "fsqrts")
+DEFINE_SUBMNEM_RC(SubMnemFSUBx, "fsub")
+DEFINE_SUBMNEM_RC(SubMnemFSUBSx, "fsubs")
+DEFINE_SUBMNEM_RC(SubMnemMFFSx, "mffs")
+DEFINE_SUBMNEM_RC(SubMnemMTFSB0x, "mtfsb0")
+DEFINE_SUBMNEM_RC(SubMnemMTFSB1x, "mtfsb1")
+DEFINE_SUBMNEM_RC(SubMnemMTFSFx, "mtfsf")
+DEFINE_SUBMNEM_RC(SubMnemMTFSFIx, "mtfsfi")
+DEFINE_SUBMNEM_RC(SubMnemMRx, "mr")
+DEFINE_SUBMNEM_RC(SubMnemMULHDx, "mulhd")
+DEFINE_SUBMNEM_RC(SubMnemMULHDUx, "mulhdu")
+DEFINE_SUBMNEM_RC(SubMnemMULHWx, "mulhw")
+DEFINE_SUBMNEM_RC(SubMnemMULHWUx, "mulhwu")
+DEFINE_SUBMNEM_OE_RC(SubMnemMULLDx, "mulld")
+DEFINE_SUBMNEM_OE_RC(SubMnemMULLWx, "mullw")
+DEFINE_SUBMNEM_RC(SubMnemNANDx, "nand")
+DEFINE_SUBMNEM_OE_RC(SubMnemNEGx, "neg")
+DEFINE_SUBMNEM_RC(SubMnemNORx, "nor")
+DEFINE_SUBMNEM_RC(SubMnemORx, "or")
+DEFINE_SUBMNEM_RC(SubMnemORIx, "ori")
+DEFINE_SUBMNEM_RC(SubMnemORCx, "orc")
+DEFINE_SUBMNEM_RC(SubMnemRLDICLx, "rldicl")
+DEFINE_SUBMNEM_RC(SubMnemRLDICRx, "rldicr")
+DEFINE_SUBMNEM_RC(SubMnemRLDICx, "rldic")
+DEFINE_SUBMNEM_RC(SubMnemRLDIMIx, "rldimi")
+DEFINE_SUBMNEM_RC(SubMnemRLDCLx, "rldcl")
+DEFINE_SUBMNEM_RC(SubMnemRLDCRx, "rldcr")
+DEFINE_SUBMNEM_RC(SubMnemRLWIMIx, "rlwimi")
+DEFINE_SUBMNEM_RC(SubMnemRLWINMx, "rlwinm")
+DEFINE_SUBMNEM_RC(SubMnemRLWNMx, "rlwnm")
+DEFINE_SUBMNEM_RC(SubMnemROTLDx, "rotld")
+DEFINE_SUBMNEM_RC(SubMnemROTLDIx, "rotldi")
+DEFINE_SUBMNEM_RC(SubMnemROTLWx, "rotlw")
+DEFINE_SUBMNEM_RC(SubMnemROTLWIx, "rotlwi")
+DEFINE_SUBMNEM_RC(SubMnemROTRDIx, "rotrdi")
+DEFINE_SUBMNEM_RC(SubMnemROTRWIx, "rotrwi")
+DEFINE_SUBMNEM_RC(SubMnemSLDx, "sld")
+DEFINE_SUBMNEM_RC(SubMnemSLDIx, "sldi")
+DEFINE_SUBMNEM_RC(SubMnemSLWx, "slw")
+DEFINE_SUBMNEM_RC(SubMnemSLWIx, "slwi")
+DEFINE_SUBMNEM_RC(SubMnemSRADx, "srad")
+DEFINE_SUBMNEM_RC(SubMnemSRADIx, "sradi")
+DEFINE_SUBMNEM_RC(SubMnemSRAWx, "sraw")
+DEFINE_SUBMNEM_RC(SubMnemSRAWIx, "srawi")
+DEFINE_SUBMNEM_RC(SubMnemSRDx, "srd")
+DEFINE_SUBMNEM_RC(SubMnemSRDIx, "srdi")
+DEFINE_SUBMNEM_RC(SubMnemSRWx, "srw")
+DEFINE_SUBMNEM_RC(SubMnemSRWIx, "srwi")
+DEFINE_SUBMNEM_OE_RC(SubMnemSUBFx, "subf")
+DEFINE_SUBMNEM_OE_RC(SubMnemSUBFCx, "subfc")
+DEFINE_SUBMNEM_OE_RC(SubMnemSUBFEx, "subfe")
+DEFINE_SUBMNEM_OE_RC(SubMnemSUBFICx, "subfic")
+DEFINE_SUBMNEM_OE_RC(SubMnemSUBFMEx, "subfme")
+DEFINE_SUBMNEM_OE_RC(SubMnemSUBFZEx, "subfze")
+DEFINE_SUBMNEM_RC(SubMnemXORx, "xor")
+DEFINE_SUBMNEM_RC(SubMnemXORIx, "xori")
+
+// ALTIVEC MNEMONICS
+DEFINE_SUBMNEM_RC(SubMnemVCMPBFPx, "vcmpbfp");
+DEFINE_SUBMNEM_RC(SubMnemVCMPEQFPx, "vcmpeqfp");
+DEFINE_SUBMNEM_RC(SubMnemVCMPEQUBx, "vcmpequb");
+DEFINE_SUBMNEM_RC(SubMnemVCMPEQUDx, "vcmpequd");
+DEFINE_SUBMNEM_RC(SubMnemVCMPEQUHx, "vcmpequh");
+DEFINE_SUBMNEM_RC(SubMnemVCMPEQUWx, "vcmpequw");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGEFPx, "vcmpgefp");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTFPx, "vcmpgtfp");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTSBx, "vcmpgtsb");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTSDx, "vcmpgtsd");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTSHx, "vcmpgtsh");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTSWx, "vcmpgtsw");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTUBx, "vcmpgtub");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTUDx, "vcmpgtud");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTUHx, "vcmpgtuh");
+DEFINE_SUBMNEM_RC(SubMnemVCMPGTUWx, "vcmpgtuw");
+DEFINE_SUBMNEM_RC(SubMnemVCMPNEBx, "vcmpneb");
+DEFINE_SUBMNEM_RC(SubMnemVCMPNEHx, "vcmpneh");
+DEFINE_SUBMNEM_RC(SubMnemVCMPNEWx, "vcmpnew");
+DEFINE_SUBMNEM_RC(SubMnemVCMPNEZBx, "vcmpnezb");
+DEFINE_SUBMNEM_RC(SubMnemVCMPNEZHx, "vcmpnezh");
+DEFINE_SUBMNEM_RC(SubMnemVCMPNEZWx, "vcmpnezw");
+
+// VSX MNEMONICS
+DEFINE_SUBMNEM_RC(SubMnemXVCMPEQDPx, "xvcmpeqdp");
+DEFINE_SUBMNEM_RC(SubMnemXVCMPEQSPx, "xvcmpeqsp");
+DEFINE_SUBMNEM_RC(SubMnemXVCMPGEDPx, "xvcmpgedp");
+DEFINE_SUBMNEM_RC(SubMnemXVCMPGESPx, "xvcmpgesp");
+DEFINE_SUBMNEM_RC(SubMnemXVCMPGTDPx, "xvcmpgtdp");
+DEFINE_SUBMNEM_RC(SubMnemXVCMPGTSPx, "xvcmpgtsp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSADDQPx, "xsaddqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSCVQPDPx, "xscvqpdp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSDIVQPx, "xsdivqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSMADDQPx, "xsmaddqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSMULQPx, "xsmulqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSMSUBQPx, "xsmsubqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSNMADDQPx, "xsnmaddqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSNMSUBQPx, "xsnmsubqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSSQRTQPx, "xssqrtqp");
+DEFINE_SUBMNEM_ROUND2ODD(SubMnemXSSUBQPx, "xssubqp");
+DEFINE_SUBMNEM_INEXACT(SubMnemXSRQPIx, "xsrqpi");
+
+// PAIREDSINGLE MNEMONICS
+DEFINE_SUBMNEM_RC(SubMnemPS_ABSx, "ps_abs");
+DEFINE_SUBMNEM_RC(SubMnemPS_ADDx, "ps_add");
+DEFINE_SUBMNEM_RC(SubMnemPS_DIVx, "ps_div");
+DEFINE_SUBMNEM_RC(SubMnemPS_MADDx, "ps_madd");
+DEFINE_SUBMNEM_RC(SubMnemPS_MADDS0x, "ps_madds0");
+DEFINE_SUBMNEM_RC(SubMnemPS_MADDS1x, "ps_madds1");
+DEFINE_SUBMNEM_RC(SubMnemPS_MERGE00x, "ps_merge00");
+DEFINE_SUBMNEM_RC(SubMnemPS_MERGE01x, "ps_merge01");
+DEFINE_SUBMNEM_RC(SubMnemPS_MERGE10x, "ps_merge10");
+DEFINE_SUBMNEM_RC(SubMnemPS_MERGE11x, "ps_merge11");
+DEFINE_SUBMNEM_RC(SubMnemPS_MRx, "ps_mr");
+DEFINE_SUBMNEM_RC(SubMnemPS_MSUBx, "ps_msub");
+DEFINE_SUBMNEM_RC(SubMnemPS_MULx, "ps_mul");
+DEFINE_SUBMNEM_RC(SubMnemPS_MULS0x, "ps_muls0");
+DEFINE_SUBMNEM_RC(SubMnemPS_MULS1x, "ps_muls1");
+DEFINE_SUBMNEM_RC(SubMnemPS_NABSx, "ps_nabs");
+DEFINE_SUBMNEM_RC(SubMnemPS_NEGx, "ps_neg");
+DEFINE_SUBMNEM_RC(SubMnemPS_NMADDx, "ps_nmadd");
+DEFINE_SUBMNEM_RC(SubMnemPS_NMSUBx, "ps_nmsub");
+DEFINE_SUBMNEM_RC(SubMnemPS_RESx, "ps_res");
+DEFINE_SUBMNEM_RC(SubMnemPS_RSQRTEx, "ps_rsqrte");
+DEFINE_SUBMNEM_RC(SubMnemPS_SELx, "ps_sel");
+DEFINE_SUBMNEM_RC(SubMnemPS_SUBx, "ps_sub");
+DEFINE_SUBMNEM_RC(SubMnemPS_SUM0x, "ps_sum0");
+DEFINE_SUBMNEM_RC(SubMnemPS_SUM1x, "ps_sum1");
+
+// VLE MNEMONICS
+DEFINE_SUBMNEM_RC(SubMnemVle32ADDIx, "e_addi");
+DEFINE_SUBMNEM_RC(SubMnemVle32ADDICx, "e_addic");
+DEFINE_SUBMNEM_RC(SubMnemVle32ANDIx, "e_andi");
+DEFINE_SUBMNEM_LK(SubMnemVle32Bx, "e_b");
+DEFINE_SUBMNEM_LK(SubMnemVle32BCx, "e_bc");
+DEFINE_SUBMNEM_LK(SubMnemVle32BDZx, "e_bdz");
+DEFINE_SUBMNEM_LK(SubMnemVle32BDNZx, "e_bdnz");
+DEFINE_SUBMNEM_LK(SubMnemVle32BEQx, "e_beq");
+DEFINE_SUBMNEM_LK(SubMnemVle32BGEx, "e_bge");
+DEFINE_SUBMNEM_LK(SubMnemVle32BGTx, "e_bgt");
+DEFINE_SUBMNEM_LK(SubMnemVle32BNEx, "e_bne");
+DEFINE_SUBMNEM_LK(SubMnemVle32BNSx, "e_bns");
+DEFINE_SUBMNEM_LK(SubMnemVle32BLEx, "e_ble");
+DEFINE_SUBMNEM_LK(SubMnemVle32BLTx, "e_blt");
+DEFINE_SUBMNEM_LK(SubMnemVle32BSOx, "e_bso");
+DEFINE_SUBMNEM_RC(SubMnemVle32ORIx, "e_ori");
+DEFINE_SUBMNEM_RC(SubMnemVle32RLWx, "e_rlw");
+DEFINE_SUBMNEM_RC(SubMnemVle32RLWIx, "e_rlwi");
+DEFINE_SUBMNEM_RC(SubMnemVle32SLWIx, "e_slwi");
+DEFINE_SUBMNEM_RC(SubMnemVle32SRWIx, "e_srwi");
+DEFINE_SUBMNEM_RC(SubMnemVle32SUBFICx, "e_subfic");
+DEFINE_SUBMNEM_RC(SubMnemVle32XORIx, "e_xori");
+
+DEFINE_SUBMNEM_RC(SubMnemVle16ANDx, "se_and");
+DEFINE_SUBMNEM_LK(SubMnemVle16Bx, "se_b");
+DEFINE_SUBMNEM_LK(SubMnemVle16BCTRx, "se_bctr");
+DEFINE_SUBMNEM_LK(SubMnemVle16BLRx, "se_blr");
+DEFINE_SUBMNEM_RC(SubMnemVle16SUBIx, "se_subi");
+
+static const char* RcMnemonic(const Instruction* instruction, const char* names[2])
+{
+	return names[instruction->flags.rc];
+}
+
+static const char* OeRcMnemonic(const Instruction* instruction, const char* names[4])
+{
+	return names[2*instruction->flags.oe + instruction->flags.rc];
+}
+
+static const char* LkMnemonic(const Instruction* instruction, const char* names[2])
+{
+	return names[instruction->flags.lk];
+}
+
+static const char* LkHintMnemonic(const Instruction* instruction, const char* names[8])
+{
+	return names[2*instruction->flags.branchLikelyHint + instruction->flags.lk];
+}
+
+static const char* AaLkMnemonic(const Instruction* instruction, const char* names[4])
+{
+	return names[2*instruction->flags.aa + instruction->flags.lk];
+}
+
+static const char* AaLkHintMnemonic(const Instruction* instruction, const char* names[16])
+{
+	return names[4*instruction->flags.branchLikelyHint + 2*instruction->flags.aa + instruction->flags.lk];
+}
+
+static const char* Round2OddMnemonic(const Instruction* instruction, const char* names[2])
+{
+	return names[instruction->flags.round2odd];
+}
+
+static const char* InexactMnemonic(const Instruction* instruction, const char* names[2])
+{
+	return names[instruction->flags.inexact];
+}
+
+const char* GetMnemonic(const Instruction* instruction)
+{
+	switch (instruction->id)
+	{
+		case PPC_ID_ADDx: return OeRcMnemonic(instruction, SubMnemADDx);
+		case PPC_ID_ADDCx: return OeRcMnemonic(instruction, SubMnemADDCx);
+		case PPC_ID_ADDEx: return OeRcMnemonic(instruction, SubMnemADDEx);
+		case PPC_ID_ADDIx:  return OeRcMnemonic(instruction, SubMnemADDIx);
+		case PPC_ID_ADDICx: return RcMnemonic(instruction, SubMnemADDICx);
+		case PPC_ID_ADDIS: return "addis";
+		case PPC_ID_ADDMEx: return OeRcMnemonic(instruction, SubMnemADDMEx);
+		case PPC_ID_ADDPCIS: return "addpcis";
+		case PPC_ID_ADDZEx: return OeRcMnemonic(instruction, SubMnemADDZEx);
+		case PPC_ID_ANDx: return RcMnemonic(instruction, SubMnemANDx);
+		case PPC_ID_ANDCx: return RcMnemonic(instruction, SubMnemANDCx);
+		case PPC_ID_ANDIx: return RcMnemonic(instruction, SubMnemANDIx);
+		case PPC_ID_ANDIS: return "andis.";
+		case PPC_ID_ATTN: return "attn";
+		case PPC_ID_Bx: return AaLkMnemonic(instruction, SubMnemBx);
+		case PPC_ID_BCx:
+		{
+			uint32_t bo = instruction->operands[0].uimm;
+			uint32_t bi = instruction->operands[1].uimm;
+
+			const char** mnemonics = NULL;
+			const char** mnemonicsHint = NULL;
+
+			// mask away the "y" bit
+			switch (bo & 0x1e)
+			{
+				case 0:
+					mnemonics = SubMnemBDNZFx;
+					break;
+
+				case 2:
+					mnemonics = SubMnemBDZFx;
+					break;
+
+				case 4:
+				case 6:
+					switch (bi & 0x3)
+					{
+						case 0:
+							mnemonicsHint = SubMnemBGEx;
+							break;
+						case 1:
+							mnemonicsHint = SubMnemBLEx;
+							break;
+						case 2:
+							mnemonicsHint = SubMnemBNEx;
+							break;
+						case 3:
+							mnemonicsHint = SubMnemBNSx;
+							break;
+
+						// should be unreachable
+						default:
+							return NULL;
+					}
+
+					break;
+
+				case 8:
+					mnemonics = SubMnemBDNZTx;
+					break;
+
+				case 10:
+					mnemonics = SubMnemBDZTx;
+					break;
+
+				case 12:
+				case 14:
+					switch (bi & 0x3)
+					{
+						case 0:
+						       mnemonicsHint = SubMnemBLTx;
+						       break;
+
+						case 1:
+						       mnemonicsHint = SubMnemBGTx;
+						       break;
+
+						case 2:
+						       mnemonicsHint = SubMnemBEQx;
+						       break;
+
+						case 3:
+						       mnemonicsHint = SubMnemBSOx;
+						       break;
+
+						// should be unreachable
+						default:
+						       return NULL;
+					}
+					break;
+
+				// technically these aren't terribly well defined
+				// when BI != 0, since these BOs don't involve
+				// a condition bit to test in BI to test against
+				case 16:
+				case 24:
+					mnemonicsHint = SubMnemBDNZx;
+					break;
+
+				// these represent "branch always" in the BO field, so it's
+				// not super clear why these disassemble to bdnz
+				case 20:
+				case 28:
+					 mnemonicsHint = SubMnemBDNZx;
+					 break;
+
+				case 18:
+				case 22:
+				case 26:
+					mnemonicsHint = SubMnemBDZx;
+					break;
+
+				// these represent "branch always" in the BO field, so it's
+				// not super clear why these disassemble to bdz
+				case 30:
+					mnemonicsHint = SubMnemBDZx;
+					break;
+
+				default:
+					mnemonics = SubMnemBCx;
+			}
+
+			if (mnemonicsHint)
+				return AaLkHintMnemonic(instruction, mnemonicsHint);
+
+			if (mnemonics)
+				return AaLkMnemonic(instruction, mnemonics);
+
+			// should be unreachable
+			return NULL;
+		}
+
+		case PPC_ID_BCCTRx:
+		{
+			uint32_t bo = instruction->operands[0].uimm;
+			uint32_t bi = instruction->operands[1].uimm;
+
+			// mask away the "y" bit
+			switch (bo & 0x1e)
+			{
+				case 4:
+				case 6:
+					switch (bi & 0x3)
+					{
+						case 0: return LkHintMnemonic(instruction, SubMnemBGECTRx);
+						case 1: return LkHintMnemonic(instruction, SubMnemBLECTRx);
+						case 2: return LkHintMnemonic(instruction, SubMnemBNECTRx);
+						case 3: return LkHintMnemonic(instruction, SubMnemBNSCTRx);
+
+						// should be unreachable
+						default: return NULL;
+					}
+
+					break;
+
+				case 12:
+				case 14:
+					switch (bi & 0x3)
+					{
+						case 0: return LkHintMnemonic(instruction, SubMnemBLTCTRx);
+						case 1: return LkHintMnemonic(instruction, SubMnemBGTCTRx);
+						case 2: return LkHintMnemonic(instruction, SubMnemBEQCTRx);
+						case 3: return LkHintMnemonic(instruction, SubMnemBSOCTRx);
+
+						// should be unreachable
+						default: return NULL;
+					}
+
+					break;
+
+				case 20:
+					return LkMnemonic(instruction, SubMnemBCTRx);
+
+				default:
+					return LkMnemonic(instruction, SubMnemBCCTRx);
+			}
+		}
+
+		case PPC_ID_BCLRx:
+		{
+			uint32_t bo = instruction->operands[0].uimm;
+			uint32_t bi = instruction->operands[1].uimm;
+
+			// mask away the "y" bit
+			switch (bo & 0x1e)
+			{
+				case 0:
+					return LkMnemonic(instruction, SubMnemBDNZFLRx);
+
+				case 2:
+					return LkMnemonic(instruction, SubMnemBDZFLRx);
+
+				case 4:
+				case 6:
+					switch (bi & 0x3)
+					{
+						case 0: return LkHintMnemonic(instruction, SubMnemBGELRx);
+						case 1: return LkHintMnemonic(instruction, SubMnemBLELRx);
+						case 2: return LkHintMnemonic(instruction, SubMnemBNELRx);
+						case 3: return LkHintMnemonic(instruction, SubMnemBNSLRx);
+
+						// should be unreachable
+						default: return NULL;
+					}
+
+				case 8:
+					return LkMnemonic(instruction, SubMnemBDNZTLRx);
+
+				case 10:
+					return LkMnemonic(instruction, SubMnemBDZTLRx);
+
+				case 12:
+				case 14:
+					switch (bi & 0x3)
+					{
+						case 0: return LkHintMnemonic(instruction, SubMnemBLTLRx);
+						case 1: return LkHintMnemonic(instruction, SubMnemBGTLRx);
+						case 2: return LkHintMnemonic(instruction, SubMnemBEQLRx);
+						case 3: return LkHintMnemonic(instruction, SubMnemBSOLRx);
+
+						// should be unreachable
+						default: return NULL;
+					}
+
+				// technically these aren't terribly well defined
+				// when BI != 0, since these BOs don't involve
+				// a condition bit to test in BI to test against
+				case 16:
+				case 24:
+					return LkHintMnemonic(instruction, SubMnemBDNZLRx);
+
+				case 18:
+				case 26:
+					return LkHintMnemonic(instruction, SubMnemBDZLRx);
+
+				case 20:
+					return LkHintMnemonic(instruction, SubMnemBLRx);
+
+				default:
+					return LkMnemonic(instruction, SubMnemBCLRx);
+			}
+		}
+
+		case PPC_ID_BPERMD: return "bpermd";
+		case PPC_ID_CLRBHRB: return "clrbhrb";
+		case PPC_ID_CLRLDIx: return RcMnemonic(instruction, SubMnemCLRLDIx);
+		case PPC_ID_CLRRDIx: return RcMnemonic(instruction, SubMnemCLRRDIx);
+		case PPC_ID_CLRLWIx: return RcMnemonic(instruction, SubMnemCLRLWIx);
+		case PPC_ID_CLRRWIx: return RcMnemonic(instruction, SubMnemCLRRWIx);
+		case PPC_ID_CMPB: return "cmpb";
+		case PPC_ID_CMPD: return "cmpd";
+		case PPC_ID_CMPDI: return "cmpdi";
+		case PPC_ID_CMPEQB: return "cmpeqb";
+		case PPC_ID_CMPRB: return "cmprb";
+		case PPC_ID_CMPW: return "cmpw";
+		case PPC_ID_CMPWI: return "cmpwi";
+		case PPC_ID_CMPLD: return "cmpld";
+		case PPC_ID_CMPLDI: return "cmpldi";
+		case PPC_ID_CMPLW: return "cmplw";
+		case PPC_ID_CMPLWI: return "cmplwi";
+		case PPC_ID_CNTLZDx: return RcMnemonic(instruction, SubMnemCNTLZDx);
+		case PPC_ID_CNTLZWx: return RcMnemonic(instruction, SubMnemCNTLZWx);
+		case PPC_ID_CNTTZDx: return RcMnemonic(instruction, SubMnemCNTTZDx);
+		case PPC_ID_CNTTZWx: return RcMnemonic(instruction, SubMnemCNTTZWx);
+		case PPC_ID_COPY: return "copy";
+		case PPC_ID_CP_ABORT: return "cp_abort";
+		case PPC_ID_CRAND: return "crand";
+		case PPC_ID_CRANDC: return "crandc";
+		case PPC_ID_CRCLR: return "crclr";
+		case PPC_ID_CREQV: return "creqv";
+		case PPC_ID_CRMOVE: return "crmove";
+		case PPC_ID_CRNAND: return "crnand";
+		case PPC_ID_CRNOR: return "crnor";
+		case PPC_ID_CRNOT: return "crnot";
+		case PPC_ID_CROR: return "cror";
+		case PPC_ID_CRORC: return "crorc";
+		case PPC_ID_CRSET: return "crset";
+		case PPC_ID_CRXOR: return "crxor";
+		case PPC_ID_DARN: return "darn";
+		case PPC_ID_DCBA: return "dcba";
+		case PPC_ID_DCBF: return "dcbf";
+		case PPC_ID_DCBFEP: return "dcbfep";
+		case PPC_ID_DCBFL: return "dcbfl";
+		case PPC_ID_DCBFLP: return "dcbflp";
+		case PPC_ID_DCBI: return "dcbi";
+		case PPC_ID_DCBST: return "dcbst";
+		case PPC_ID_DCBSTEP: return "dcbstep";
+		case PPC_ID_DCBT: return "dcbt";
+		case PPC_ID_DCBTT: return "dcbtt";
+		case PPC_ID_DCBTEP: return "dcbtep";
+		case PPC_ID_DCBTST: return "dcbtst";
+		case PPC_ID_DCBTSTEP: return "dcbtstep";
+		case PPC_ID_DCBTSTT: return "dcbtstt";
+		case PPC_ID_DCBZ: return "dcbz";
+		case PPC_ID_DCBZEP: return "dcbzep";
+		case PPC_ID_DCBZL: return "dcbzl";
+		case PPC_ID_DCCCI: return "dccci";
+		case PPC_ID_DCI: return "dci";
+		case PPC_ID_DIVDx: return OeRcMnemonic(instruction, SubMnemDIVDx);
+		case PPC_ID_DIVDEx: return OeRcMnemonic(instruction, SubMnemDIVDEx);
+		case PPC_ID_DIVDEUx: return OeRcMnemonic(instruction, SubMnemDIVDEUx);
+		case PPC_ID_DIVDUx: return OeRcMnemonic(instruction, SubMnemDIVDUx);
+		case PPC_ID_DIVWx: return OeRcMnemonic(instruction, SubMnemDIVWx);
+		case PPC_ID_DIVWEx: return OeRcMnemonic(instruction, SubMnemDIVWEx);
+		case PPC_ID_DIVWEUx: return OeRcMnemonic(instruction, SubMnemDIVWEUx);
+		case PPC_ID_DIVWUx: return OeRcMnemonic(instruction, SubMnemDIVWUx);
+		case PPC_ID_ECIWX: return "eciwx";
+		case PPC_ID_ECOWX: return "ecowx";
+		case PPC_ID_EIEIO: return "eieio";
+		case PPC_ID_EQVx: return RcMnemonic(instruction, SubMnemEQVx);
+		case PPC_ID_EXTLDIx: return RcMnemonic(instruction, SubMnemEXTLDIx);
+		case PPC_ID_EXTRDIx: return RcMnemonic(instruction, SubMnemEXTRDIx);
+		case PPC_ID_EXTLWIx: return RcMnemonic(instruction, SubMnemEXTLWIx);
+		case PPC_ID_EXTRWIx: return RcMnemonic(instruction, SubMnemEXTRWIx);
+		case PPC_ID_EXTSBx: return RcMnemonic(instruction, SubMnemEXTSBx);
+		case PPC_ID_EXTSHx: return RcMnemonic(instruction, SubMnemEXTSHx);
+		case PPC_ID_EXTSWx: return RcMnemonic(instruction, SubMnemEXTSWx);
+		case PPC_ID_EXTSWSLIx: return RcMnemonic(instruction, SubMnemEXTSWSLIx);
+		case PPC_ID_FABSx: return RcMnemonic(instruction, SubMnemFABSx);
+		case PPC_ID_FADDx: return RcMnemonic(instruction, SubMnemFADDx);
+		case PPC_ID_FADDSx: return RcMnemonic(instruction, SubMnemFADDSx);
+		case PPC_ID_FCFIDx: return RcMnemonic(instruction, SubMnemFCFIDx);
+		case PPC_ID_FCFIDSx: return RcMnemonic(instruction, SubMnemFCFIDSx);
+		case PPC_ID_FCFIDUx: return RcMnemonic(instruction, SubMnemFCFIDUx);
+		case PPC_ID_FCFIDUSx: return RcMnemonic(instruction, SubMnemFCFIDUSx);
+		case PPC_ID_FCMPO: return "fcmpo";
+		case PPC_ID_FCMPU: return "fcmpu";
+		case PPC_ID_FCPSGNx: return RcMnemonic(instruction, SubMnemFCPSGNx);
+		case PPC_ID_FCTIDx: return RcMnemonic(instruction, SubMnemFCTIDx);
+		case PPC_ID_FCTIDUx: return RcMnemonic(instruction, SubMnemFCTIDUx);
+		case PPC_ID_FCTIDUZx: return RcMnemonic(instruction, SubMnemFCTIDUZx);
+		case PPC_ID_FCTIDZx: return RcMnemonic(instruction, SubMnemFCTIDZx);
+		case PPC_ID_FCTIWx: return RcMnemonic(instruction, SubMnemFCTIWx);
+		case PPC_ID_FCTIWUx: return RcMnemonic(instruction, SubMnemFCTIWUx);
+		case PPC_ID_FCTIWUZx: return RcMnemonic(instruction, SubMnemFCTIWUZx);
+		case PPC_ID_FCTIWZx: return RcMnemonic(instruction, SubMnemFCTIWZx);
+		case PPC_ID_FDIVx: return RcMnemonic(instruction, SubMnemFDIVx);
+		case PPC_ID_FDIVSx: return RcMnemonic(instruction, SubMnemFDIVSx);
+		case PPC_ID_FMADDx: return RcMnemonic(instruction, SubMnemFMADDx);
+		case PPC_ID_FMADDSx: return RcMnemonic(instruction, SubMnemFMADDSx);
+		case PPC_ID_FMRx: return RcMnemonic(instruction, SubMnemFMRx);
+		case PPC_ID_FMSUBx: return RcMnemonic(instruction, SubMnemFMSUBx);
+		case PPC_ID_FMSUBSx: return RcMnemonic(instruction, SubMnemFMSUBSx);
+		case PPC_ID_FMULx: return RcMnemonic(instruction, SubMnemFMULx);
+		case PPC_ID_FMULSx: return RcMnemonic(instruction, SubMnemFMULSx);
+		case PPC_ID_FNABSx: return RcMnemonic(instruction, SubMnemFNABSx);
+		case PPC_ID_FNEGx: return RcMnemonic(instruction, SubMnemFNEGx);
+		case PPC_ID_FNMADDx: return RcMnemonic(instruction, SubMnemFNMADDx);
+		case PPC_ID_FNMADDSx: return RcMnemonic(instruction, SubMnemFNMADDSx);
+		case PPC_ID_FNMSUBx: return RcMnemonic(instruction, SubMnemFNMSUBx);
+		case PPC_ID_FNMSUBSx: return RcMnemonic(instruction, SubMnemFNMSUBSx);
+		case PPC_ID_FREx: return RcMnemonic(instruction, SubMnemFREx);
+		case PPC_ID_FRESx: return RcMnemonic(instruction, SubMnemFRESx);
+		case PPC_ID_FRIMx: return RcMnemonic(instruction, SubMnemFRIMx);
+		case PPC_ID_FRINx: return RcMnemonic(instruction, SubMnemFRINx);
+		case PPC_ID_FRIPx: return RcMnemonic(instruction, SubMnemFRIPx);
+		case PPC_ID_FRIZx: return RcMnemonic(instruction, SubMnemFRIZx);
+		case PPC_ID_FRSPx:  return RcMnemonic(instruction, SubMnemFRSPx);
+		case PPC_ID_FRSQRTEx:  return RcMnemonic(instruction, SubMnemFRSQRTEx);
+		case PPC_ID_FRSQRTESx:  return RcMnemonic(instruction, SubMnemFRSQRTESx);
+		case PPC_ID_FSELx:  return RcMnemonic(instruction, SubMnemFSELx);
+		case PPC_ID_FSQRTx:  return RcMnemonic(instruction, SubMnemFSQRTx);
+		case PPC_ID_FSQRTSx:  return RcMnemonic(instruction, SubMnemFSQRTSx);
+		case PPC_ID_FSUBx:  return RcMnemonic(instruction, SubMnemFSUBx);
+		case PPC_ID_FSUBSx:  return RcMnemonic(instruction, SubMnemFSUBSx);
+		case PPC_ID_FTDIV: return "ftdiv";
+		case PPC_ID_FTSQRT: return "ftsqrt";
+		case PPC_ID_HRFID: return "hrfid";
+		case PPC_ID_ICBI: return "icbi";
+		case PPC_ID_ICBIEP: return "icbiep";
+		case PPC_ID_ICBLC: return "icblc";
+		case PPC_ID_ICBLQ: return "icblq.";
+		case PPC_ID_ICBT: return "icbt";
+		case PPC_ID_ICBTLS: return "icbtls";
+		case PPC_ID_ICCCI: return "iccci";
+		case PPC_ID_ICI: return "ici";
+		case PPC_ID_ISEL: return "isel";
+		case PPC_ID_ISYNC: return "isync";
+		case PPC_ID_LBARX: return "lbarx";
+		case PPC_ID_LBEPX: return "lbepx";
+		case PPC_ID_LBZ: return "lbz";
+		case PPC_ID_LBZCIX: return "lbzcix";
+		case PPC_ID_LBZU: return "lbzu";
+		case PPC_ID_LBZUX: return "lbzux";
+		case PPC_ID_LBZX: return "lbzx";
+		case PPC_ID_LDARX: return "ldarx";
+		case PPC_ID_LDAT: return "ldat";
+		case PPC_ID_LDBRX: return "ldbrx";
+		case PPC_ID_LDCIX: return "ldcix";
+		case PPC_ID_LD: return "ld";
+		case PPC_ID_LDU: return "ldu";
+		case PPC_ID_LDUX: return "ldux";
+		case PPC_ID_LDX: return "ldx";
+		case PPC_ID_LFD: return "lfd";
+		case PPC_ID_LFDEPX: return "lfdepx";
+		case PPC_ID_LFDU: return "lfdu";
+		case PPC_ID_LFDUX: return "lfdux";
+		case PPC_ID_LFDX: return "lfdx";
+		case PPC_ID_LFIWAX: return "lfiwax";
+		case PPC_ID_LFIWZX: return "lfiwzx";
+		case PPC_ID_LFS: return "lfs";
+		case PPC_ID_LFSU: return "lfsu";
+		case PPC_ID_LFSUX: return "lfsux";
+		case PPC_ID_LFSX: return "lfsx";
+		case PPC_ID_LHA: return "lha";
+		case PPC_ID_LHARX: return "lharx";
+		case PPC_ID_LHAU: return "lhau";
+		case PPC_ID_LHAUX: return "lhaux";
+		case PPC_ID_LHAX: return "lhax";
+		case PPC_ID_LHBRX: return "lhbrx";
+		case PPC_ID_LHEPX: return "lhepx";
+		case PPC_ID_LHZ: return "lhz";
+		case PPC_ID_LHZCIX: return "lhzcix";
+		case PPC_ID_LHZU: return "lhzu";
+		case PPC_ID_LHZUX: return "lhzux";
+		case PPC_ID_LHZX: return "lhzx";
+		case PPC_ID_LI: return "li";
+		case PPC_ID_LIS: return "lis";
+		case PPC_ID_LMW: return "lmw";
+		case PPC_ID_LNIA: return "lnia";
+		case PPC_ID_LSWI: return "lswi";
+		case PPC_ID_LSWX: return "lswx";
+		case PPC_ID_LWA: return "lwa";
+		case PPC_ID_LWAT: return "lwat";
+		case PPC_ID_LWAX: return "lwax";
+		case PPC_ID_LWARX: return "lwarx";
+		case PPC_ID_LWAUX: return "lwaux";
+		case PPC_ID_LWBRX: return "lwbrx";
+		case PPC_ID_LWEPX: return "lwepx";
+		case PPC_ID_LWSYNC: return "lwsync";
+		case PPC_ID_LWZ: return "lwz";
+		case PPC_ID_LWZCIX: return "lwzcix";
+		case PPC_ID_LWZU: return "lwzu";
+		case PPC_ID_LWZUX: return "lwzux";
+		case PPC_ID_LWZX: return "lwzx";
+		case PPC_ID_MBAR: return "mbar";
+		case PPC_ID_MCRF: return "mcrf";
+		case PPC_ID_MCRFS: return "mcrfs";
+		case PPC_ID_MCRXR: return "mcrxr";
+		case PPC_ID_MCRXRX: return "mcrxrx";
+		case PPC_ID_MFBHRBE: return "mfbhrbe";
+		case PPC_ID_MFBR0: return "mfbr0";
+		case PPC_ID_MFBR1: return "mfbr1";
+		case PPC_ID_MFBR2: return "mfbr2";
+		case PPC_ID_MFBR3: return "mfbr3";
+		case PPC_ID_MFBR4: return "mfbr4";
+		case PPC_ID_MFBR5: return "mfbr5";
+		case PPC_ID_MFBR6: return "mfbr6";
+		case PPC_ID_MFBR7: return "mfbr7";
+		case PPC_ID_MFCR: return "mfcr";
+		case PPC_ID_MFCTR: return "mfctr";
+		case PPC_ID_MFDCR: return "mfdcr";
+		case PPC_ID_MFDCRUX: return "mfdcrux";
+		case PPC_ID_MFDCRX: return "mfdcrx";
+		case PPC_ID_MFFSx: return RcMnemonic(instruction, SubMnemMFFSx);
+		case PPC_ID_MFFSCDRN: return "mffscdrn";
+		case PPC_ID_MFFSCDRNI: return "mffscdrni";
+		case PPC_ID_MFFSCE: return "mffsce";
+		case PPC_ID_MFFSCRN: return "mffscrn";
+		case PPC_ID_MFFSCRNI: return "mffscrni";
+		case PPC_ID_MFFSL: return "mffsl";
+		case PPC_ID_MFLR: return "mflr";
+		case PPC_ID_MFMSR: return "mfmsr";
+		case PPC_ID_MFOCRF: return "mfocrf";
+		case PPC_ID_MFPMR: return "mfpmr";
+		case PPC_ID_MFSPR: return "mfspr";
+		case PPC_ID_MFSR: return "mfsr";
+		case PPC_ID_MFSRIN: return "mfsrin";
+		case PPC_ID_MFTB: return "mftb";
+		case PPC_ID_MFTBU: return "mftbu";
+		case PPC_ID_MFXER: return "mfxer";
+		case PPC_ID_MRx: return RcMnemonic(instruction, SubMnemMRx);
+		case PPC_ID_MSGSYNC: return "msgsync";
+		case PPC_ID_MTAMR: return "mtamr";
+		case PPC_ID_MTBR0: return "mtbr0";
+		case PPC_ID_MTBR1: return "mtbr1";
+		case PPC_ID_MTBR2: return "mtbr2";
+		case PPC_ID_MTBR3: return "mtbr3";
+		case PPC_ID_MTBR4: return "mtbr4";
+		case PPC_ID_MTBR5: return "mtbr5";
+		case PPC_ID_MTBR6: return "mtbr6";
+		case PPC_ID_MTBR7: return "mtbr7";
+		case PPC_ID_MTCRF: return "mtcrf";
+		case PPC_ID_MTCTR: return "mtctr";
+		case PPC_ID_MTDCR: return "mtdcr";
+		case PPC_ID_MTDCRUX: return "mtdcrux";
+		case PPC_ID_MTDCRX: return "mtdcrx";
+		case PPC_ID_MTFSB0x: return RcMnemonic(instruction, SubMnemMTFSB0x);
+		case PPC_ID_MTFSB1x: return RcMnemonic(instruction, SubMnemMTFSB1x);
+		case PPC_ID_MTFSFx: return RcMnemonic(instruction, SubMnemMTFSFx);
+		case PPC_ID_MTFSFIx: return RcMnemonic(instruction, SubMnemMTFSFIx);
+		case PPC_ID_MODSD: return "modsd";
+		case PPC_ID_MODSW: return "modsw";
+		case PPC_ID_MODUD: return "modud";
+		case PPC_ID_MODUW: return "moduw";
+		case PPC_ID_MTLR: return "mtlr";
+		case PPC_ID_MTMSR: return "mtmsr";
+		case PPC_ID_MTMSRD: return "mtmsrd";
+		case PPC_ID_MTOCRF: return "mtocrf";
+		case PPC_ID_MTPMR: return "mtpmr";
+		case PPC_ID_MTSPR: return "mtspr";
+		case PPC_ID_MTSR: return "mtsr";
+		case PPC_ID_MTSRIN: return "mtsrin";
+		case PPC_ID_MTXER: return "mtxer";
+		case PPC_ID_MULHDx: return RcMnemonic(instruction, SubMnemMULHDx);
+		case PPC_ID_MULHDUx: return RcMnemonic(instruction, SubMnemMULHDUx);
+		case PPC_ID_MULHWx: return RcMnemonic(instruction, SubMnemMULHWx);
+		case PPC_ID_MULHWUx: return RcMnemonic(instruction, SubMnemMULHWUx);
+		case PPC_ID_MULLI: return "mulli";
+		case PPC_ID_MULLDx: return OeRcMnemonic(instruction, SubMnemMULLDx);
+		case PPC_ID_MULLWx: return OeRcMnemonic(instruction, SubMnemMULLWx);
+		case PPC_ID_NANDx: return RcMnemonic(instruction, SubMnemNANDx);
+		case PPC_ID_NAP: return "nap";
+		case PPC_ID_NEGx: return OeRcMnemonic(instruction, SubMnemNEGx);
+		case PPC_ID_NOP: return "nop";
+		case PPC_ID_NORx: return RcMnemonic(instruction, SubMnemNORx);
+		case PPC_ID_ORx: return RcMnemonic(instruction, SubMnemORx);
+		case PPC_ID_ORCx: return RcMnemonic(instruction, SubMnemORCx);
+		case PPC_ID_ORIx: return RcMnemonic(instruction, SubMnemORIx);
+		case PPC_ID_ORIS: return "oris";
+		case PPC_ID_PASTE: return "paste.";
+		case PPC_ID_POPCNTB: return "popcntb";
+		case PPC_ID_POPCNTD: return "popcntd";
+		case PPC_ID_POPCNTW: return "popcntw";
+		case PPC_ID_PTESYNC: return "ptesync";
+		case PPC_ID_RFCI: return "rfci";
+		case PPC_ID_RFDI: return "rfdi";
+		case PPC_ID_RFEBB: return "rfebb";
+		case PPC_ID_RFI: return "rfi";
+		case PPC_ID_RFID: return "rfid";
+		case PPC_ID_RFMCI: return "rfmci";
+		case PPC_ID_RLDICLx: return RcMnemonic(instruction, SubMnemRLDICLx);
+		case PPC_ID_RLDICRx: return RcMnemonic(instruction, SubMnemRLDICRx);
+		case PPC_ID_RLDICx: return RcMnemonic(instruction, SubMnemRLDICx);
+		case PPC_ID_RLDIMIx: return RcMnemonic(instruction, SubMnemRLDIMIx);
+		case PPC_ID_RLDCLx: return RcMnemonic(instruction, SubMnemRLDCLx);
+		case PPC_ID_RLDCRx: return RcMnemonic(instruction, SubMnemRLDCRx);
+		case PPC_ID_RLWIMIx: return RcMnemonic(instruction, SubMnemRLWIMIx);
+		case PPC_ID_RLWINMx: return RcMnemonic(instruction, SubMnemRLWINMx);
+		case PPC_ID_RLWNMx: return RcMnemonic(instruction, SubMnemRLWNMx);
+		case PPC_ID_ROTLDx: return RcMnemonic(instruction, SubMnemROTLDx);
+		case PPC_ID_ROTLDIx: return RcMnemonic(instruction, SubMnemROTLDIx);
+		case PPC_ID_ROTLWx: return RcMnemonic(instruction, SubMnemROTLWx);
+		case PPC_ID_ROTLWIx: return RcMnemonic(instruction, SubMnemROTLWIx);
+		case PPC_ID_ROTRDIx: return RcMnemonic(instruction, SubMnemROTRDIx);
+		case PPC_ID_ROTRWIx: return RcMnemonic(instruction, SubMnemROTRWIx);
+		case PPC_ID_SC: return "sc";
+		case PPC_ID_SETB: return "setb";
+		case PPC_ID_SLBIA: return "slbia";
+		case PPC_ID_SLBIE: return "slbie";
+		case PPC_ID_SLBIEG: return "slbieg";
+		case PPC_ID_SLBMFEE: return "slbmfee";
+		case PPC_ID_SLBMFEV: return "slbmfev";
+		case PPC_ID_SLBMTE: return "slbmte";
+		case PPC_ID_SLBSYNC: return "slbsync";
+		case PPC_ID_SLDx: return RcMnemonic(instruction, SubMnemSLDx);
+		case PPC_ID_SLDIx: return RcMnemonic(instruction, SubMnemSLDIx);
+		case PPC_ID_SLWx: return RcMnemonic(instruction, SubMnemSLWx);
+		case PPC_ID_SLWIx: return RcMnemonic(instruction, SubMnemSLWIx);
+		case PPC_ID_SRADx: return RcMnemonic(instruction, SubMnemSRADx);
+		case PPC_ID_SRADIx: return RcMnemonic(instruction, SubMnemSRADIx);
+		case PPC_ID_SRAWx: return RcMnemonic(instruction, SubMnemSRAWx);
+		case PPC_ID_SRAWIx: return RcMnemonic(instruction, SubMnemSRAWIx);
+		case PPC_ID_SRDx: return RcMnemonic(instruction, SubMnemSRDx);
+		case PPC_ID_SRDIx: return RcMnemonic(instruction, SubMnemSRDIx);
+		case PPC_ID_SRWx: return RcMnemonic(instruction, SubMnemSRWx);
+		case PPC_ID_SRWIx: return RcMnemonic(instruction, SubMnemSRWIx);
+		case PPC_ID_STB: return "stb";
+		case PPC_ID_STBCIX: return "stbcix";
+		case PPC_ID_STBCX: return "stbcx.";
+		case PPC_ID_STBEPX: return "stbepx";
+		case PPC_ID_STBU: return "stbu";
+		case PPC_ID_STBUX: return "stbux";
+		case PPC_ID_STBX: return "stbx";
+		case PPC_ID_STD: return "std";
+		case PPC_ID_STDAT: return "stdat";
+		case PPC_ID_STDBRX: return "stdbrx";
+		case PPC_ID_STDCIX: return "stdcix";
+		case PPC_ID_STDCX: return "stdcx.";
+		case PPC_ID_STDEPX: return "stdepx";
+		case PPC_ID_STDU: return "stdu";
+		case PPC_ID_STDUX: return "stdux";
+		case PPC_ID_STDX: return "stdx";
+		case PPC_ID_STFD: return "stfd";
+		case PPC_ID_STFDEPX: return "stfdepx";
+		case PPC_ID_STFDU: return "stfdu";
+		case PPC_ID_STFDUX: return "stfdux";
+		case PPC_ID_STFDX: return "stfdx";
+		case PPC_ID_STFIWX: return "stfiwx";
+		case PPC_ID_STFS: return "stfs";
+		case PPC_ID_STFSU: return "stfsu";
+		case PPC_ID_STFSUX: return "stfsux";
+		case PPC_ID_STFSX: return "stfsx";
+		case PPC_ID_STH: return "sth";
+		case PPC_ID_STHBRX: return "sthbrx";
+		case PPC_ID_STHCIX: return "sthcix";
+		case PPC_ID_STHCX: return "sthcx.";
+		case PPC_ID_STHEPX: return "sthepx";
+		case PPC_ID_STHU: return "sthu";
+		case PPC_ID_STHUX: return "sthux";
+		case PPC_ID_STHX: return "sthx";
+		case PPC_ID_STMW: return "stmw";
+		case PPC_ID_STOP: return "stop";
+		case PPC_ID_STSWI: return "stswi";
+		case PPC_ID_STSWX: return "stswx";
+		case PPC_ID_STW: return "stw";
+		case PPC_ID_STWAT: return "stwat";
+		case PPC_ID_STWBRX: return "stwbrx";
+		case PPC_ID_STWCIX: return "stwcix";
+		case PPC_ID_STWCX: return "stwcx.";
+		case PPC_ID_STWEPX: return "stwepx";
+		case PPC_ID_STWU: return "stwu";
+		case PPC_ID_STWUX: return "stwux";
+		case PPC_ID_STWX: return "stwx";
+		case PPC_ID_SUBFx: return OeRcMnemonic(instruction, SubMnemSUBFx);
+		case PPC_ID_SUBFCx: return OeRcMnemonic(instruction, SubMnemSUBFCx);
+		case PPC_ID_SUBFEx: return OeRcMnemonic(instruction, SubMnemSUBFEx);
+		case PPC_ID_SUBFICx: return OeRcMnemonic(instruction, SubMnemSUBFICx);
+		case PPC_ID_SUBFMEx: return OeRcMnemonic(instruction, SubMnemSUBFMEx);
+		case PPC_ID_SUBFZEx: return OeRcMnemonic(instruction, SubMnemSUBFZEx);
+		case PPC_ID_SYNC: return "sync";
+		case PPC_ID_TABORT: return "tabort.";
+		case PPC_ID_TABORTDC: return "tabortdc.";
+		case PPC_ID_TABORTDCI: return "tabortdci.";
+		case PPC_ID_TABORTWC: return "tabortwc.";
+		case PPC_ID_TABORTWCI: return "tabortwci.";
+		case PPC_ID_TBEGIN: return "tbegin.";
+		case PPC_ID_TCHECK: return "tcheck";
+		case PPC_ID_TD: return "td";
+		case PPC_ID_TDEQ: return "tdeq";
+		case PPC_ID_TDEQI: return "tdeqi";
+		case PPC_ID_TDGT: return "tdgt";
+		case PPC_ID_TDGTI: return "tdgti";
+		case PPC_ID_TDI: return "tdi";
+		case PPC_ID_TDLGT: return "tdlgt";
+		case PPC_ID_TDLGTI: return "tdlgti";
+		case PPC_ID_TDLLT: return "tdllt";
+		case PPC_ID_TDLLTI: return "tdllti";
+		case PPC_ID_TDLT: return "tdlt";
+		case PPC_ID_TDLTI: return "tdlti";
+		case PPC_ID_TDNE: return "tdne";
+		case PPC_ID_TDNEI: return "tdnei";
+		case PPC_ID_TDU: return "tdu";
+		case PPC_ID_TDUI: return "tdui";
+		case PPC_ID_TEND: return "tend.";
+		case PPC_ID_TLBIA: return "tlbia";
+		case PPC_ID_TLBIE: return "tlbie";
+		case PPC_ID_TLBIEL: return "tlbiel";
+		case PPC_ID_TLBIVAX: return "tlbivax";
+		case PPC_ID_TLBLI: return "tlbli";
+		case PPC_ID_TLBSX: return "tlbsx";
+		case PPC_ID_TLBSYNC: return "tlbsync";
+		case PPC_ID_TLBRE: return "tlbre";
+		case PPC_ID_TLBRELO: return "tlbrehi";
+		case PPC_ID_TLBREHI: return "tlbrelo";
+		case PPC_ID_TLBWE: return "tlbwe";
+		case PPC_ID_TLBWEHI: return "tlbwehi";
+		case PPC_ID_TLBWELO: return "tlbwelo";
+		case PPC_ID_TRAP: return "trap";
+		case PPC_ID_TRECHKPT: return "trechkpt.";
+		case PPC_ID_TRECLAIM: return "treclaim.";
+		case PPC_ID_TSR: return "tsr.";
+		case PPC_ID_TW: return "tw";
+		case PPC_ID_TWEQ: return "tweq";
+		case PPC_ID_TWEQI: return "tweqi";
+		case PPC_ID_TWGT: return "twgt";
+		case PPC_ID_TWGTI: return "twgti";
+		case PPC_ID_TWGEI: return "twgei";
+		case PPC_ID_TWI: return "twi";
+		case PPC_ID_TWLEI: return "twlei";
+		case PPC_ID_TWLLEI: return "twllei";
+		case PPC_ID_TWLGT: return "twlgt";
+		case PPC_ID_TWLGTI: return "twlgti";
+		case PPC_ID_TWLLT: return "twllt";
+		case PPC_ID_TWLLTI: return "twllti";
+		case PPC_ID_TWLT: return "twlt";
+		case PPC_ID_TWLTI: return "twlti";
+		case PPC_ID_TWNE: return "twne";
+		case PPC_ID_TWNEI: return "twnei";
+		case PPC_ID_TWU: return "twu";
+		case PPC_ID_TWUI: return "twui";
+		case PPC_ID_WAIT: return "wait";
+		case PPC_ID_WAITIMPL: return "waitimpl";
+		case PPC_ID_WAITRSV: return "waitrsv";
+		case PPC_ID_WRTEE: return "wrtee";
+		case PPC_ID_WRTEEI: return "wrteei";
+		case PPC_ID_XNOP: return "xnop";
+		case PPC_ID_XORx: return RcMnemonic(instruction, SubMnemXORx);
+		case PPC_ID_XORIx: return RcMnemonic(instruction, SubMnemXORIx);
+		case PPC_ID_XORIS: return "xoris";
+
+		case PPC_ID_AV_VABSDUB: return "vabsdub";
+		case PPC_ID_AV_VABSDUH: return "vabsduh";
+		case PPC_ID_AV_VABSDUW: return "vabsduw";
+		case PPC_ID_AV_VADDUQM: return "vadduqm";
+		case PPC_ID_AV_VADDCUQ: return "vaddcuq";
+		case PPC_ID_AV_BCDADD: return "bcdadd.";
+		case PPC_ID_AV_BCDCFN: return "bcdcfn.";
+		case PPC_ID_AV_BCDCFSQ: return "bcdcfsq.";
+		case PPC_ID_AV_BCDCFZ: return "bcdcfz.";
+		case PPC_ID_AV_BCDCPSGN: return "bcdcpsgn.";
+		case PPC_ID_AV_BCDCTN: return "bcdctn.";
+		case PPC_ID_AV_BCDCTSQ: return "bcdctsq.";
+		case PPC_ID_AV_BCDCTZ: return "bcdctz.";
+		case PPC_ID_AV_BCDS: return "bcds.";
+		case PPC_ID_AV_BCDSETSGN: return "bcdsetsgn.";
+		case PPC_ID_AV_BCDSR: return "bcdsr.";
+		case PPC_ID_AV_BCDSUB: return "bcdsub.";
+		case PPC_ID_AV_BCDTRUNC: return "bcdtrunc.";
+		case PPC_ID_AV_BCDUS: return "bcdus.";
+		case PPC_ID_AV_BCDUTRUNC: return "bcdutrunc.";
+		case PPC_ID_AV_DSS: return "dss";
+		case PPC_ID_AV_DSSALL: return "dssall";
+		case PPC_ID_AV_DST: return "dst";
+		case PPC_ID_AV_DSTST: return "dstst";
+		case PPC_ID_AV_DSTSTT: return "dststt";
+		case PPC_ID_AV_DSTT: return "dstt";
+		case PPC_ID_AV_LVEBX: return "lvebx";
+		case PPC_ID_AV_LVEHX: return "lvehx";
+		case PPC_ID_AV_LVEWX: return "lvewx";
+		case PPC_ID_AV_LVSL: return "lvsl";
+		case PPC_ID_AV_LVSR: return "lvsr";
+		case PPC_ID_AV_LVX: return "lvx";
+		case PPC_ID_AV_LVXL: return "lvxl";
+		case PPC_ID_AV_MADDHD: return "maddhd";
+		case PPC_ID_AV_MADDHDU: return "maddhdu";
+		case PPC_ID_AV_MADDLD: return "maddld";
+		case PPC_ID_AV_MFVSCR: return "mfvscr";
+		case PPC_ID_AV_MTVSCR: return "mtvscr";
+		case PPC_ID_AV_STVEBX: return "stvebx";
+		case PPC_ID_AV_STVEHX: return "stvehx";
+		case PPC_ID_AV_STVEWX: return "stvewx";
+		case PPC_ID_AV_STVX: return "stvx";
+		case PPC_ID_AV_STVXL: return "stvxl";
+		case PPC_ID_AV_VADDCUW: return "vaddcuw";
+		case PPC_ID_AV_VADDECUQ: return "vaddecuq";
+		case PPC_ID_AV_VADDEUQM: return "vaddeuqm";
+		case PPC_ID_AV_VADDFP: return "vaddfp";
+		case PPC_ID_AV_VADDSBS: return "vaddsbs";
+		case PPC_ID_AV_VADDSHS: return "vaddshs";
+		case PPC_ID_AV_VADDSWS: return "vaddsws";
+		case PPC_ID_AV_VADDUBM: return "vaddubm";
+		case PPC_ID_AV_VADDUBS: return "vaddubs";
+		case PPC_ID_AV_VADDUDM: return "vaddudm";
+		case PPC_ID_AV_VADDUHM: return "vadduhm";
+		case PPC_ID_AV_VADDUHS: return "vadduhs";
+		case PPC_ID_AV_VADDUWM: return "vadduwm";
+		case PPC_ID_AV_VADDUWS: return "vadduws";
+		case PPC_ID_AV_VAND: return "vand";
+		case PPC_ID_AV_VANDC: return "vandc";
+		case PPC_ID_AV_VAVGSB: return "vavgsb";
+		case PPC_ID_AV_VAVGSH: return "vavgsh";
+		case PPC_ID_AV_VAVGSW: return "vavgsw";
+		case PPC_ID_AV_VAVGUB: return "vavgub";
+		case PPC_ID_AV_VAVGUH: return "vavguh";
+		case PPC_ID_AV_VAVGUW: return "vavguw";
+		case PPC_ID_AV_VBPERMD: return "vbpermd";
+		case PPC_ID_AV_VBPERMQ: return "vbpermq";
+		case PPC_ID_AV_VCFSX: return "vcfsx";
+		case PPC_ID_AV_VCFUX: return "vcfux";
+		case PPC_ID_AV_VCIPHER: return "vcipher";
+		case PPC_ID_AV_VCIPHERLAST: return "vcipherlast";
+		case PPC_ID_AV_VCLZB: return "vclzb";
+		case PPC_ID_AV_VCLZD: return "vclzd";
+		case PPC_ID_AV_VCLZH: return "vclzh";
+		case PPC_ID_AV_VCLZLSBB: return "vclzlsbb";
+		case PPC_ID_AV_VCLZW: return "vclzw";
+		case PPC_ID_AV_VCMPBFPx: return RcMnemonic(instruction, SubMnemVCMPBFPx);
+		case PPC_ID_AV_VCMPEQFPx: return RcMnemonic(instruction, SubMnemVCMPEQFPx);
+		case PPC_ID_AV_VCMPEQUBx: return RcMnemonic(instruction, SubMnemVCMPEQUBx);
+		case PPC_ID_AV_VCMPEQUDx: return RcMnemonic(instruction, SubMnemVCMPEQUDx);
+		case PPC_ID_AV_VCMPEQUHx: return RcMnemonic(instruction, SubMnemVCMPEQUHx);
+		case PPC_ID_AV_VCMPEQUWx: return RcMnemonic(instruction, SubMnemVCMPEQUWx);
+		case PPC_ID_AV_VCMPGEFPx: return RcMnemonic(instruction, SubMnemVCMPGEFPx);
+		case PPC_ID_AV_VCMPGTFPx: return RcMnemonic(instruction, SubMnemVCMPGTFPx);
+		case PPC_ID_AV_VCMPGTSBx: return RcMnemonic(instruction, SubMnemVCMPGTSBx);
+		case PPC_ID_AV_VCMPGTSDx: return RcMnemonic(instruction, SubMnemVCMPGTSDx);
+		case PPC_ID_AV_VCMPGTSHx: return RcMnemonic(instruction, SubMnemVCMPGTSHx);
+		case PPC_ID_AV_VCMPGTSWx: return RcMnemonic(instruction, SubMnemVCMPGTSWx);
+		case PPC_ID_AV_VCMPGTUBx: return RcMnemonic(instruction, SubMnemVCMPGTUBx);
+		case PPC_ID_AV_VCMPGTUDx: return RcMnemonic(instruction, SubMnemVCMPGTUDx);
+		case PPC_ID_AV_VCMPGTUHx: return RcMnemonic(instruction, SubMnemVCMPGTUHx);
+		case PPC_ID_AV_VCMPGTUWx: return RcMnemonic(instruction, SubMnemVCMPGTUWx);
+		case PPC_ID_AV_VCMPNEBx: return RcMnemonic(instruction, SubMnemVCMPNEBx);
+		case PPC_ID_AV_VCMPNEHx: return RcMnemonic(instruction, SubMnemVCMPNEHx);
+		case PPC_ID_AV_VCMPNEWx: return RcMnemonic(instruction, SubMnemVCMPNEWx);
+		case PPC_ID_AV_VCMPNEZBx: return RcMnemonic(instruction, SubMnemVCMPNEZBx);
+		case PPC_ID_AV_VCMPNEZHx: return RcMnemonic(instruction, SubMnemVCMPNEZHx);
+		case PPC_ID_AV_VCMPNEZWx: return RcMnemonic(instruction, SubMnemVCMPNEZWx);
+		case PPC_ID_AV_VCTSXS: return "vctsxs";
+		case PPC_ID_AV_VCTUXS: return "vctuxs";
+		case PPC_ID_AV_VCTZB: return "vctzb";
+		case PPC_ID_AV_VCTZD: return "vctzd";
+		case PPC_ID_AV_VCTZH: return "vctzh";
+		case PPC_ID_AV_VCTZLSBB: return "vctzlsbb";
+		case PPC_ID_AV_VCTZW: return "vctzw";
+		case PPC_ID_AV_VEQV: return "veqv";
+		case PPC_ID_AV_VEXPTEFP: return "vexptefp";
+		case PPC_ID_AV_VEXTRACTD: return "vextractd";
+		case PPC_ID_AV_VEXTRACTUB: return "vextractub";
+		case PPC_ID_AV_VEXTRACTUH: return "vextractuh";
+		case PPC_ID_AV_VEXTRACTUW: return "vextractuw";
+		case PPC_ID_AV_VEXTSB2D: return "vextsb2d";
+		case PPC_ID_AV_VEXTSB2W: return "vextsb2w";
+		case PPC_ID_AV_VEXTSH2D: return "vextsh2d";
+		case PPC_ID_AV_VEXTSH2W: return "vextsh2w";
+		case PPC_ID_AV_VEXTSW2D: return "vextsw2d";
+		case PPC_ID_AV_VEXTUBLX: return "vextublx";
+		case PPC_ID_AV_VEXTUHLX: return "vextuhlx";
+		case PPC_ID_AV_VEXTUWLX: return "vextuwlx";
+		case PPC_ID_AV_VEXTUBRX: return "vextubrx";
+		case PPC_ID_AV_VEXTUHRX: return "vextuhrx";
+		case PPC_ID_AV_VEXTUWRX: return "vextuwrx";
+		case PPC_ID_AV_VGBBD: return "vgbbd";
+		case PPC_ID_AV_VINSERTB: return "vinsertb";
+		case PPC_ID_AV_VINSERTD: return "vinsertd";
+		case PPC_ID_AV_VINSERTH: return "vinserth";
+		case PPC_ID_AV_VINSERTW: return "vinsertw";
+		case PPC_ID_AV_VLOGEFP: return "vlogefp";
+		case PPC_ID_AV_VMADDFP: return "vmaddfp";
+		case PPC_ID_AV_VMAXFP: return "vmaxfp";
+		case PPC_ID_AV_VMAXSB: return "vmaxsb";
+		case PPC_ID_AV_VMAXSD: return "vmaxsd";
+		case PPC_ID_AV_VMAXSH: return "vmaxsh";
+		case PPC_ID_AV_VMAXSW: return "vmaxsw";
+		case PPC_ID_AV_VMAXUB: return "vmaxub";
+		case PPC_ID_AV_VMAXUD: return "vmaxud";
+		case PPC_ID_AV_VMAXUH: return "vmaxuh";
+		case PPC_ID_AV_VMAXUW: return "vmaxuw";
+		case PPC_ID_AV_VMHADDSHS: return "vmhaddshs";
+		case PPC_ID_AV_VMHRADDSHS: return "vmhraddshs";
+		case PPC_ID_AV_VMINFP: return "vminfp";
+		case PPC_ID_AV_VMINSB: return "vminsb";
+		case PPC_ID_AV_VMINSD: return "vminsd";
+		case PPC_ID_AV_VMINSH: return "vminsh";
+		case PPC_ID_AV_VMINSW: return "vminsw";
+		case PPC_ID_AV_VMINUB: return "vminub";
+		case PPC_ID_AV_VMINUD: return "vminud";
+		case PPC_ID_AV_VMINUH: return "vminuh";
+		case PPC_ID_AV_VMINUW: return "vminuw";
+		case PPC_ID_AV_VMLADDUHM: return "vmladduhm";
+		case PPC_ID_AV_VMR: return "vmr";
+		case PPC_ID_AV_VMRGEW: return "vmrgew";
+		case PPC_ID_AV_VMRGHB: return "vmrghb";
+		case PPC_ID_AV_VMRGHH: return "vmrghh";
+		case PPC_ID_AV_VMRGHW: return "vmrghw";
+		case PPC_ID_AV_VMRGLB: return "vmrglb";
+		case PPC_ID_AV_VMRGLH: return "vmrglh";
+		case PPC_ID_AV_VMRGLW: return "vmrglw";
+		case PPC_ID_AV_VMRGOW: return "vmrgow";
+		case PPC_ID_AV_VMSUMMBM: return "vmsummbm";
+		case PPC_ID_AV_VMSUMSHM: return "vmsumshm";
+		case PPC_ID_AV_VMSUMSHS: return "vmsumshs";
+		case PPC_ID_AV_VMSUMUBM: return "vmsumubm";
+		case PPC_ID_AV_VMSUMUHM: return "vmsumuhm";
+		case PPC_ID_AV_VMSUMUHS: return "vmsumuhs";
+		case PPC_ID_AV_VMUL10CUQ: return "vmul10cuq";
+		case PPC_ID_AV_VMUL10EUQ: return "vmul10euq";
+		case PPC_ID_AV_VMUL10ECUQ: return "vmul10ecuq";
+		case PPC_ID_AV_VMUL10UQ: return "vmul10uq";
+		case PPC_ID_AV_VMULESB: return "vmulesb";
+		case PPC_ID_AV_VMULESH: return "vmulesh";
+		case PPC_ID_AV_VMULESW: return "vmulesw";
+		case PPC_ID_AV_VMULEUB: return "vmuleub";
+		case PPC_ID_AV_VMULEUH: return "vmuleuh";
+		case PPC_ID_AV_VMULEUW: return "vmuleuw";
+		case PPC_ID_AV_VMULOSB: return "vmulosb";
+		case PPC_ID_AV_VMULOSH: return "vmulosh";
+		case PPC_ID_AV_VMULOSW: return "vmulosw";
+		case PPC_ID_AV_VMULOUB: return "vmuloub";
+		case PPC_ID_AV_VMULOUH: return "vmulouh";
+		case PPC_ID_AV_VMULOUW: return "vmulouw";
+		case PPC_ID_AV_VMULUWM: return "vmuluwm";
+		case PPC_ID_AV_VNAND: return "vnand";
+		case PPC_ID_AV_VNCIPHER: return "vncipher";
+		case PPC_ID_AV_VNCIPHERLAST: return "vncipherlast";
+		case PPC_ID_AV_VNMSUBFP: return "vnmsubfp";
+		case PPC_ID_AV_VNEGD: return "vnegd";
+		case PPC_ID_AV_VNEGW: return "vnegw";
+		case PPC_ID_AV_VNOR: return "vnor";
+		case PPC_ID_AV_VNOT: return "vnot";
+		case PPC_ID_AV_VOR: return "vor";
+		case PPC_ID_AV_VORC: return "vorc";
+		case PPC_ID_AV_VPERM: return "vperm";
+		case PPC_ID_AV_VPERMR: return "vpermr";
+		case PPC_ID_AV_VPERMXOR: return "vpermxor";
+		case PPC_ID_AV_VPKPX: return "vpkpx";
+		case PPC_ID_AV_VPKSDSS: return "vpksdss";
+		case PPC_ID_AV_VPKSDUS: return "vpksdus";
+		case PPC_ID_AV_VPKSHSS: return "vpkshss";
+		case PPC_ID_AV_VPKSHUS: return "vpkshus";
+		case PPC_ID_AV_VPKSWSS: return "vpkswss";
+		case PPC_ID_AV_VPKSWUS: return "vpkswus";
+		case PPC_ID_AV_VPKUDUM: return "vpkudum";
+		case PPC_ID_AV_VPKUDUS: return "vpkudus";
+		case PPC_ID_AV_VPKUHUM: return "vpkuhum";
+		case PPC_ID_AV_VPKUHUS: return "vpkuhus";
+		case PPC_ID_AV_VPKUWUM: return "vpkuwum";
+		case PPC_ID_AV_VPKUWUS: return "vpkuwus";
+		case PPC_ID_AV_VPMSUMB: return "vpmsumb";
+		case PPC_ID_AV_VPMSUMD: return "vpmsumd";
+		case PPC_ID_AV_VPMSUMH: return "vpmsumh";
+		case PPC_ID_AV_VPMSUMW: return "vpmsumw";
+		case PPC_ID_AV_VPOPCNTB: return "vpopcntb";
+		case PPC_ID_AV_VPOPCNTD: return "vpopcntd";
+		case PPC_ID_AV_VPOPCNTH: return "vpopcnth";
+		case PPC_ID_AV_VPOPCNTW: return "vpopcntw";
+		case PPC_ID_AV_VPRTYBD: return "vprtybd";
+		case PPC_ID_AV_VPRTYBQ: return "vprtybq";
+		case PPC_ID_AV_VPRTYBW: return "vprtybw";
+		case PPC_ID_AV_VREFP: return "vrefp";
+		case PPC_ID_AV_VRFIM: return "vrfim";
+		case PPC_ID_AV_VRFIN: return "vrfin";
+		case PPC_ID_AV_VRFIP: return "vrfip";
+		case PPC_ID_AV_VRFIZ: return "vrfiz";
+		case PPC_ID_AV_VRLB: return "vrlb";
+		case PPC_ID_AV_VRLD: return "vrld";
+		case PPC_ID_AV_VRLDNM: return "vrldnm";
+		case PPC_ID_AV_VRLDMI: return "vrldmi";
+		case PPC_ID_AV_VRLH: return "vrlh";
+		case PPC_ID_AV_VRLW: return "vrlw";
+		case PPC_ID_AV_VRLWMI: return "vrlwmi";
+		case PPC_ID_AV_VRLWNM: return "vrlwnm";
+		case PPC_ID_AV_VRSQRTEFP: return "vrsqrtefp";
+		case PPC_ID_AV_VSBOX: return "vsbox";
+		case PPC_ID_AV_VSEL: return "vsel";
+		case PPC_ID_AV_VSHASIGMAD: return "vshasigmad";
+		case PPC_ID_AV_VSHASIGMAW: return "vshasigmaw";
+		case PPC_ID_AV_VSL: return "vsl";
+		case PPC_ID_AV_VSLB: return "vslb";
+		case PPC_ID_AV_VSLD: return "vsld";
+		case PPC_ID_AV_VSLDOI: return "vsldoi";
+		case PPC_ID_AV_VSLH: return "vslh";
+		case PPC_ID_AV_VSLO: return "vslo";
+		case PPC_ID_AV_VSLV: return "vslv";
+		case PPC_ID_AV_VSLW: return "vslw";
+		case PPC_ID_AV_VSPLTB: return "vspltb";
+		case PPC_ID_AV_VSPLTH: return "vsplth";
+		case PPC_ID_AV_VSPLTISB: return "vspltisb";
+		case PPC_ID_AV_VSPLTISH: return "vspltish";
+		case PPC_ID_AV_VSPLTISW: return "vspltisw";
+		case PPC_ID_AV_VSPLTW: return "vspltw";
+		case PPC_ID_AV_VSR: return "vsr";
+		case PPC_ID_AV_VSRAB: return "vsrab";
+		case PPC_ID_AV_VSRAD: return "vsrad";
+		case PPC_ID_AV_VSRAH: return "vsrah";
+		case PPC_ID_AV_VSRAW: return "vsraw";
+		case PPC_ID_AV_VSRB: return "vsrb";
+		case PPC_ID_AV_VSRD: return "vsrd";
+		case PPC_ID_AV_VSRH: return "vsrh";
+		case PPC_ID_AV_VSRO: return "vsro";
+		case PPC_ID_AV_VSRV: return "vsrv";
+		case PPC_ID_AV_VSRW: return "vsrw";
+		case PPC_ID_AV_VSUBCUQ: return "vsubcuq";
+		case PPC_ID_AV_VSUBCUW: return "vsubcuw";
+		case PPC_ID_AV_VSUBECUQ: return "vsubecuq";
+		case PPC_ID_AV_VSUBEUQM: return "vsubeuqm";
+		case PPC_ID_AV_VSUBFP: return "vsubfp";
+		case PPC_ID_AV_VSUBSBS: return "vsubsbs";
+		case PPC_ID_AV_VSUBSHS: return "vsubshs";
+		case PPC_ID_AV_VSUBSWS: return "vsubsws";
+		case PPC_ID_AV_VSUBUBM: return "vsububm";
+		case PPC_ID_AV_VSUBUBS: return "vsububs";
+		case PPC_ID_AV_VSUBUDM: return "vsubudm";
+		case PPC_ID_AV_VSUBUHM: return "vsubuhm";
+		case PPC_ID_AV_VSUBUHS: return "vsubuhs";
+		case PPC_ID_AV_VSUBUQM: return "vsubuqm";
+		case PPC_ID_AV_VSUBUWM: return "vsubuwm";
+		case PPC_ID_AV_VSUBUWS: return "vsubuws";
+		case PPC_ID_AV_VSUMSWS: return "vsumsws";
+		case PPC_ID_AV_VSUM2SWS: return "vsum2sws";
+		case PPC_ID_AV_VSUM4SBS: return "vsum4sbs";
+		case PPC_ID_AV_VSUM4SHS: return "vsum4shs";
+		case PPC_ID_AV_VSUM4UBS: return "vsum4ubs";
+		case PPC_ID_AV_VUPKHPX: return "vupkhpx";
+		case PPC_ID_AV_VUPKHSB: return "vupkhsb";
+		case PPC_ID_AV_VUPKHSH: return "vupkhsh";
+		case PPC_ID_AV_VUPKHSW: return "vupkhsw";
+		case PPC_ID_AV_VUPKLPX: return "vupklpx";
+		case PPC_ID_AV_VUPKLSB: return "vupklsb";
+		case PPC_ID_AV_VUPKLSH: return "vupklsh";
+		case PPC_ID_AV_VUPKLSW: return "vupklsw";
+		case PPC_ID_AV_VXOR: return "vxor";
+
+		case PPC_ID_VSX_LXSD: return "lxsd";
+		case PPC_ID_VSX_LXSDX: return "lxsdx";
+		case PPC_ID_VSX_LXSIBZX: return "lxsibzx";
+		case PPC_ID_VSX_LXSIHZX: return "lxsihzx";
+		case PPC_ID_VSX_LXSIWAX: return "lxsiwax";
+		case PPC_ID_VSX_LXSIWZX: return "lxsiwzx";
+		case PPC_ID_VSX_LXSSP: return "lxssp";
+		case PPC_ID_VSX_LXSSPX: return "lxsspx";
+		case PPC_ID_VSX_LXV: return "lxv";
+		case PPC_ID_VSX_LXVB16X: return "lxvb16x";
+		case PPC_ID_VSX_LXVD2X: return "lxvd2x";
+		case PPC_ID_VSX_LXVDSX: return "lxvdsx";
+		case PPC_ID_VSX_LXVH8X: return "lxvh8x";
+		case PPC_ID_VSX_LXVL: return "lxvl";
+		case PPC_ID_VSX_LXVLL: return "lxvll";
+		case PPC_ID_VSX_LXVW4X: return "lxvw4x";
+		case PPC_ID_VSX_LXVWSX: return "lxvwsx";
+		case PPC_ID_VSX_LXVX: return "lxvx";
+		case PPC_ID_VSX_MFFPRD: return "mffprd";
+		case PPC_ID_VSX_MFVSRD: return "mfvsrd";
+		case PPC_ID_VSX_MFVSRLD: return "mfvsrld";
+		case PPC_ID_VSX_MFVSRWZ: return "mfvsrwz";
+		case PPC_ID_VSX_MTVSRD: return "mtvsrd";
+		case PPC_ID_VSX_MTVSRDD: return "mtvsrdd";
+		case PPC_ID_VSX_MTVSRWA: return "mtvsrwa";
+		case PPC_ID_VSX_MTVSRWS: return "mtvsrws";
+		case PPC_ID_VSX_MTVSRWZ: return "mtvsrwz";
+		case PPC_ID_VSX_STXSD: return "stxsd";
+		case PPC_ID_VSX_STXSDX: return "stxsdx";
+		case PPC_ID_VSX_STXSIBX: return "stxsibx";
+		case PPC_ID_VSX_STXSIHX: return "stxsihx";
+		case PPC_ID_VSX_STXSIWX: return "stxsiwx";
+		case PPC_ID_VSX_STXSSP: return "stxssp";
+		case PPC_ID_VSX_STXSSPX: return "stxsspx";
+		case PPC_ID_VSX_STXVB16X: return "stxvb16x";
+		case PPC_ID_VSX_STXVD2X: return "stxvd2x";
+		case PPC_ID_VSX_STXVH8X: return "stxvh8x";
+		case PPC_ID_VSX_STXV: return "stxv";
+		case PPC_ID_VSX_STXVL: return "stxvl";
+		case PPC_ID_VSX_STXVLL: return "stxvll";
+		case PPC_ID_VSX_STXVW4X: return "stxvw4x";
+		case PPC_ID_VSX_STXVX: return "stxvx";
+		case PPC_ID_VSX_XSABSDP: return "xsabsdp";
+		case PPC_ID_VSX_XSABSQP: return "xsabsqp";
+		case PPC_ID_VSX_XSADDDP: return "xsadddp";
+		case PPC_ID_VSX_XSADDSP: return "xsaddsp";
+		case PPC_ID_VSX_XSADDQPx: return Round2OddMnemonic(instruction, SubMnemXSADDQPx);
+		case PPC_ID_VSX_XSCMPEQDP: return "xscmpeqdp";
+		case PPC_ID_VSX_XSCMPEXPDP: return "xscmpexpdp";
+		case PPC_ID_VSX_XSCMPEXPQP: return "xscmpexpqp";
+		case PPC_ID_VSX_XSCMPGEDP: return "xscmpgedp";
+		case PPC_ID_VSX_XSCMPGTDP: return "xscmpgtdp";
+		case PPC_ID_VSX_XSCMPODP: return "xscmpodp";
+		case PPC_ID_VSX_XSCMPOQP: return "xscmpoqp";
+		case PPC_ID_VSX_XSCMPUDP: return "xscmpudp";
+		case PPC_ID_VSX_XSCMPUQP: return "xscmpuqp";
+		case PPC_ID_VSX_XSCPSGNDP: return "xscpsgndp";
+		case PPC_ID_VSX_XSCPSGNQP: return "xscpsgnqp";
+		case PPC_ID_VSX_XSCVDPHP: return "xscvdphp";
+		case PPC_ID_VSX_XSCVDPQP: return "xscvdpqp";
+		case PPC_ID_VSX_XSCVDPSP: return "xscvdpsp";
+		case PPC_ID_VSX_XSCVDPSPN: return "xscvdpspn";
+		case PPC_ID_VSX_XSCVDPSXDS: return "xscvdpsxds";
+		case PPC_ID_VSX_XSCVDPSXWS: return "xscvdpsxws";
+		case PPC_ID_VSX_XSCVDPUXDS: return "xscvdpuxds";
+		case PPC_ID_VSX_XSCVDPUXWS: return "xscvdpuxws";
+		case PPC_ID_VSX_XSCVHPDP: return "xscvhpdp";
+		case PPC_ID_VSX_XSCVQPDPx: return Round2OddMnemonic(instruction, SubMnemXSCVQPDPx);
+		case PPC_ID_VSX_XSCVQPSDZ: return "xscvqpsdz";
+		case PPC_ID_VSX_XSCVQPSWZ: return "xscvqpswz";
+		case PPC_ID_VSX_XSCVQPUDZ: return "xscvqpudz";
+		case PPC_ID_VSX_XSCVQPUWZ: return "xscvqpuwz";
+		case PPC_ID_VSX_XSCVSDQP: return "xscvsdqp";
+		case PPC_ID_VSX_XSCVSPDP: return "xscvspdp";
+		case PPC_ID_VSX_XSCVSPDPN: return "xscvspdpn";
+		case PPC_ID_VSX_XSCVSXDDP: return "xscvsxddp";
+		case PPC_ID_VSX_XSCVSXDSP: return "xscvsxdsp";
+		case PPC_ID_VSX_XSCVUDQP: return "xscvudqp";
+		case PPC_ID_VSX_XSCVUXDDP: return "xscvuxddp";
+		case PPC_ID_VSX_XSCVUXDSP: return "xscvuxdsp";
+		case PPC_ID_VSX_XSDIVDP: return "xsdivdp";
+		case PPC_ID_VSX_XSDIVSP: return "xsdivsp";
+		case PPC_ID_VSX_XSDIVQPx: return Round2OddMnemonic(instruction, SubMnemXSDIVQPx);
+		case PPC_ID_VSX_XSIEXPDP: return "xsiexpdp";
+		case PPC_ID_VSX_XSIEXPQP: return "xsiexpqp";
+		case PPC_ID_VSX_XSMADDADP: return "xsmaddadp";
+		case PPC_ID_VSX_XSMADDASP: return "xsmaddasp";
+		case PPC_ID_VSX_XSMADDMDP: return "xsmaddmdp";
+		case PPC_ID_VSX_XSMADDMSP: return "xsmaddmsp";
+		case PPC_ID_VSX_XSMADDQPx: return Round2OddMnemonic(instruction, SubMnemXSMADDQPx);
+		case PPC_ID_VSX_XSMAXCDP: return "xsmaxcdp";
+		case PPC_ID_VSX_XSMAXDP: return "xsmaxdp";
+		case PPC_ID_VSX_XSMAXJDP: return "xsmaxjdp";
+		case PPC_ID_VSX_XSMINDP: return "xsmindp";
+		case PPC_ID_VSX_XSMINCDP: return "xsmincdp";
+		case PPC_ID_VSX_XSMINJDP: return "xsminjdp";
+		case PPC_ID_VSX_XSMSUBADP: return "xsmsubadp";
+		case PPC_ID_VSX_XSMSUBASP: return "xsmsubasp";
+		case PPC_ID_VSX_XSMSUBMDP: return "xsmsubmdp";
+		case PPC_ID_VSX_XSMSUBMSP: return "xsmsubmsp";
+		case PPC_ID_VSX_XSMSUBQPx: return Round2OddMnemonic(instruction, SubMnemXSMSUBQPx);
+		case PPC_ID_VSX_XSMULDP: return "xsmuldp";
+		case PPC_ID_VSX_XSMULSP: return "xsmulsp";
+		case PPC_ID_VSX_XSMULQPx: return Round2OddMnemonic(instruction, SubMnemXSMULQPx);
+		case PPC_ID_VSX_XSNABSDP: return "xsnabsdp";
+		case PPC_ID_VSX_XSNABSQP: return "xsnabsqp";
+		case PPC_ID_VSX_XSNEGDP: return "xsnegdp";
+		case PPC_ID_VSX_XSNEGQP: return "xsnegqp";
+		case PPC_ID_VSX_XSNMADDADP: return "xsnmaddadp";
+		case PPC_ID_VSX_XSNMADDASP: return "xsnmaddasp";
+		case PPC_ID_VSX_XSNMADDQPx: return Round2OddMnemonic(instruction, SubMnemXSNMADDQPx);
+		case PPC_ID_VSX_XSNMADDMDP: return "xsnmaddmdp";
+		case PPC_ID_VSX_XSNMADDMSP: return "xsnmaddmsp";
+		case PPC_ID_VSX_XSNMSUBADP: return "xsnmsubadp";
+		case PPC_ID_VSX_XSNMSUBASP: return "xsnmsubasp";
+		case PPC_ID_VSX_XSNMSUBMDP: return "xsnmsubmdp";
+		case PPC_ID_VSX_XSNMSUBMSP: return "xsnmsubmsp";
+		case PPC_ID_VSX_XSNMSUBQPx: return Round2OddMnemonic(instruction, SubMnemXSNMSUBQPx);
+		case PPC_ID_VSX_XSRDPI: return "xsrdpi";
+		case PPC_ID_VSX_XSRDPIC: return "xsrdpic";
+		case PPC_ID_VSX_XSRDPIM: return "xsrdpim";
+		case PPC_ID_VSX_XSRDPIP: return "xsrdpip";
+		case PPC_ID_VSX_XSRDPIZ: return "xsrdpiz";
+		case PPC_ID_VSX_XSREDP: return "xsredp";
+		case PPC_ID_VSX_XSRESP: return "xsresp";
+		case PPC_ID_VSX_XSRSP: return "xsrsp";
+		case PPC_ID_VSX_XSRSQRTEDP: return "xsrsqrtedp";
+		case PPC_ID_VSX_XSRSQRTESP: return "xsrsqrtesp";
+		case PPC_ID_VSX_XSSQRTDP: return "xssqrtdp";
+		case PPC_ID_VSX_XSSQRTQPx: return Round2OddMnemonic(instruction, SubMnemXSSQRTQPx);
+		case PPC_ID_VSX_XSSQRTSP: return "xssqrtsp";
+		case PPC_ID_VSX_XSSUBDP: return "xssubdp";
+		case PPC_ID_VSX_XSSUBSP: return "xssubsp";
+		case PPC_ID_VSX_XSSUBQPx: return Round2OddMnemonic(instruction, SubMnemXSSUBQPx);
+		case PPC_ID_VSX_XSRQPIx: return InexactMnemonic(instruction, SubMnemXSRQPIx);
+		case PPC_ID_VSX_XSRQPXP: return "xsrqpxp";
+		case PPC_ID_VSX_XSTDIVDP: return "xstdivdp";
+		case PPC_ID_VSX_XSTDIVSP: return "xstdivsp";
+		case PPC_ID_VSX_XSTSTDCDP: return "xststdcdp";
+		case PPC_ID_VSX_XSTSTDCQP: return "xststdcqp";
+		case PPC_ID_VSX_XSTSTDCSP: return "xststdcsp";
+		case PPC_ID_VSX_XSTSQRTDP: return "xstsqrtdp";
+		case PPC_ID_VSX_XSXEXPDP: return "xsxexpdp";
+		case PPC_ID_VSX_XSXEXPQP: return "xsxexpqp";
+		case PPC_ID_VSX_XSXSIGDP: return "xsxsigdp";
+		case PPC_ID_VSX_XSXSIGQP: return "xsxsigqp";
+		case PPC_ID_VSX_XVABSSP: return "xvabssp";
+		case PPC_ID_VSX_XVABSDP: return "xvabsdp";
+		case PPC_ID_VSX_XVADDSP: return "xvaddsp";
+		case PPC_ID_VSX_XVADDDP: return "xvadddp";
+		case PPC_ID_VSX_XVCMPEQDPx: return RcMnemonic(instruction, SubMnemXVCMPEQDPx);
+		case PPC_ID_VSX_XVCMPEQSPx: return RcMnemonic(instruction, SubMnemXVCMPEQSPx);
+		case PPC_ID_VSX_XVCMPGEDPx: return RcMnemonic(instruction, SubMnemXVCMPGEDPx);
+		case PPC_ID_VSX_XVCMPGESPx: return RcMnemonic(instruction, SubMnemXVCMPGESPx);
+		case PPC_ID_VSX_XVCMPGTDPx: return RcMnemonic(instruction, SubMnemXVCMPGTDPx);
+		case PPC_ID_VSX_XVCMPGTSPx: return RcMnemonic(instruction, SubMnemXVCMPGTSPx);
+		case PPC_ID_VSX_XVCPSGNDP: return "xvcpsgndp";
+		case PPC_ID_VSX_XVCPSGNSP: return "xvcpsgnsp";
+		case PPC_ID_VSX_XVCVDPSP: return "xvcvdpsp";
+		case PPC_ID_VSX_XVCVDPSXDS: return "xvcvdpsxds";
+		case PPC_ID_VSX_XVCVDPSXWS: return "xvcvdpsxws";
+		case PPC_ID_VSX_XVCVDPUXDS: return "xvcvdpuxds";
+		case PPC_ID_VSX_XVCVDPUXWS: return "xvcvdpuxws";
+		case PPC_ID_VSX_XVCVHPSP: return "xvcvhpsp";
+		case PPC_ID_VSX_XVCVSPDP: return "xvcvspdp";
+		case PPC_ID_VSX_XVCVSPHP: return "xvcvsphp";
+		case PPC_ID_VSX_XVCVSPSXDS: return "xvcvspsxds";
+		case PPC_ID_VSX_XVCVSPSXWS: return "xvcvspsxws";
+		case PPC_ID_VSX_XVCVSPUXDS: return "xvcvspuxds";
+		case PPC_ID_VSX_XVCVSPUXWS: return "xvcvspuxws";
+		case PPC_ID_VSX_XVCVSXDDP: return "xvcvsxddp";
+		case PPC_ID_VSX_XVCVSXDSP: return "xvcvsxdsp";
+		case PPC_ID_VSX_XVCVSXWDP: return "xvcvsxwdp";
+		case PPC_ID_VSX_XVCVSXWSP: return "xvcvsxwsp";
+		case PPC_ID_VSX_XVCVUXDDP: return "xvcvuxddp";
+		case PPC_ID_VSX_XVCVUXDSP: return "xvcvuxdsp";
+		case PPC_ID_VSX_XVCVUXWDP: return "xvcvuxwdp";
+		case PPC_ID_VSX_XVCVUXWSP: return "xvcvuxwsp";
+		case PPC_ID_VSX_XVDIVDP: return "xvdivdp";
+		case PPC_ID_VSX_XVDIVSP: return "xvdivsp";
+		case PPC_ID_VSX_XVIEXPDP: return "xviexpdp";
+		case PPC_ID_VSX_XVIEXPSP: return "xviexpsp";
+		case PPC_ID_VSX_XVMADDADP: return "xvmaddadp";
+		case PPC_ID_VSX_XVMADDASP: return "xvmaddasp";
+		case PPC_ID_VSX_XVMADDMDP: return "xvmaddmdp";
+		case PPC_ID_VSX_XVMADDMSP: return "xvmaddmsp";
+		case PPC_ID_VSX_XVMAXDP: return "xvmaxdp";
+		case PPC_ID_VSX_XVMAXSP: return "xvmaxsp";
+		case PPC_ID_VSX_XVMINDP: return "xvmindp";
+		case PPC_ID_VSX_XVMINSP: return "xvminsp";
+		case PPC_ID_VSX_XVMOVDP: return "xvmovdp";
+		case PPC_ID_VSX_XVMOVSP: return "xvmovsp";
+		case PPC_ID_VSX_XVMSUBADP: return "xvmsubadp";
+		case PPC_ID_VSX_XVMSUBASP: return "xvmsubasp";
+		case PPC_ID_VSX_XVMSUBMDP: return "xvmsubmdp";
+		case PPC_ID_VSX_XVMSUBMSP: return "xvmsubmsp";
+		case PPC_ID_VSX_XVMULSP: return "xvmulsp";
+		case PPC_ID_VSX_XVMULDP: return "xvmuldp";
+		case PPC_ID_VSX_XVNABSDP: return "xvnabsdp";
+		case PPC_ID_VSX_XVNABSSP: return "xvnabssp";
+		case PPC_ID_VSX_XVNMADDADP: return "xvnmaddadp";
+		case PPC_ID_VSX_XVNMADDASP: return "xvnmaddasp";
+		case PPC_ID_VSX_XVNMADDMDP: return "xvnmaddmdp";
+		case PPC_ID_VSX_XVNMADDMSP: return "xvnmaddmsp";
+		case PPC_ID_VSX_XVNEGDP: return "xvnegdp";
+		case PPC_ID_VSX_XVNEGSP: return "xvnegsp";
+		case PPC_ID_VSX_XVNMSUBADP: return "xvnmsubadp";
+		case PPC_ID_VSX_XVNMSUBASP: return "xvnmsubasp";
+		case PPC_ID_VSX_XVNMSUBMSP: return "xvnmsubmsp";
+		case PPC_ID_VSX_XVNMSUBMDP: return "xvnmsubmdp";
+		case PPC_ID_VSX_XVRDPI: return "xvrdpi";
+		case PPC_ID_VSX_XVRDPIC: return "xvrdpic";
+		case PPC_ID_VSX_XVRDPIM: return "xvrdpim";
+		case PPC_ID_VSX_XVRDPIP: return "xvrdpip";
+		case PPC_ID_VSX_XVRDPIZ: return "xvrdpiz";
+		case PPC_ID_VSX_XVREDP: return "xvredp";
+		case PPC_ID_VSX_XVRESP: return "xvresp";
+		case PPC_ID_VSX_XVRSPI: return "xvrspi";
+		case PPC_ID_VSX_XVRSPIC: return "xvrspic";
+		case PPC_ID_VSX_XVRSPIM: return "xvrspim";
+		case PPC_ID_VSX_XVRSPIP: return "xvrspip";
+		case PPC_ID_VSX_XVRSPIZ: return "xvrspiz";
+		case PPC_ID_VSX_XVRSQRTEDP: return "xvrsqrtedp";
+		case PPC_ID_VSX_XVRSQRTESP: return "xvrsqrtesp";
+		case PPC_ID_VSX_XVSQRTDP: return "xvsqrtdp";
+		case PPC_ID_VSX_XVSQRTSP: return "xvsqrtsp";
+		case PPC_ID_VSX_XVSUBSP: return "xvsubsp";
+		case PPC_ID_VSX_XVSUBDP: return "xvsubdp";
+		case PPC_ID_VSX_XVTDIVDP: return "xvtdivdp";
+		case PPC_ID_VSX_XVTDIVSP: return "xvtdivsp";
+		case PPC_ID_VSX_XVTSQRTDP: return "xvtsqrtdp";
+		case PPC_ID_VSX_XVTSQRTSP: return "xvtsqrtsp";
+		case PPC_ID_VSX_XVTSTDCDP: return "xvtstdcdp";
+		case PPC_ID_VSX_XVTSTDCSP: return "xvtstdcsp";
+		case PPC_ID_VSX_XVXEXPDP: return "xvxexpdp";
+		case PPC_ID_VSX_XVXEXPSP: return "xvxexpsp";
+		case PPC_ID_VSX_XVXSIGDP: return "xvxsigdp";
+		case PPC_ID_VSX_XVXSIGSP: return "xvxsigsp";
+		case PPC_ID_VSX_XXBRD: return "xxbrd";
+		case PPC_ID_VSX_XXBRH: return "xxbrh";
+		case PPC_ID_VSX_XXBRQ: return "xxbrq";
+		case PPC_ID_VSX_XXBRW: return "xxbrw";
+		case PPC_ID_VSX_XXEXTRACTUW: return "xxextractuw";
+		case PPC_ID_VSX_XXINSERTW: return "xxinsertw";
+		case PPC_ID_VSX_XXLAND: return "xxland";
+		case PPC_ID_VSX_XXLANDC: return "xxlandc";
+		case PPC_ID_VSX_XXLEQV: return "xxleqv";
+		case PPC_ID_VSX_XXLNAND: return "xxlnand";
+		case PPC_ID_VSX_XXLNOR: return "xxlnor";
+		case PPC_ID_VSX_XXLORC: return "xxlorc";
+		case PPC_ID_VSX_XXMRGHD: return "xxmrghd";
+		case PPC_ID_VSX_XXMRGHW: return "xxmrghw";
+		case PPC_ID_VSX_XXMRGLD: return "xxmrgld";
+		case PPC_ID_VSX_XXMRGLW: return "xxmrglw";
+		case PPC_ID_VSX_XXLOR: return "xxlor";
+		case PPC_ID_VSX_XXLXOR: return "xxlxor";
+		case PPC_ID_VSX_XXPERM: return "xxperm";
+		case PPC_ID_VSX_XXPERMDI: return "xxpermdi";
+		case PPC_ID_VSX_XXPERMR: return "xxpermr";
+		case PPC_ID_VSX_XXSEL: return "xxsel";
+		case PPC_ID_VSX_XXSLDWI: return "xxsldwi";
+		case PPC_ID_VSX_XXSPLTD: return "xxspltd";
+		case PPC_ID_VSX_XXSPLTIB: return "xxspltib";
+		case PPC_ID_VSX_XXSPLTW: return "xxspltw";
+		case PPC_ID_VSX_XXSWAPD: return "xxswapd";
+
+		case PPC_ID_PSQ_L: return "psq_l";
+		case PPC_ID_PSQ_LU: return "psq_lu";
+		case PPC_ID_PSQ_LUX: return "psq_lux";
+		case PPC_ID_PSQ_LX: return "psq_lx";
+		case PPC_ID_PSQ_ST: return "psq_st";
+		case PPC_ID_PSQ_STU: return "psq_stu";
+		case PPC_ID_PSQ_STUX: return "psq_stux";
+		case PPC_ID_PSQ_STX: return "psq_stx";
+
+		case PPC_ID_PAIREDSINGLE_DCBZ_L: return "dcbz_l";
+		case PPC_ID_PAIREDSINGLE_PS_ABSx: return RcMnemonic(instruction, SubMnemPS_ABSx);
+		case PPC_ID_PAIREDSINGLE_PS_ADDx: return RcMnemonic(instruction, SubMnemPS_ADDx);
+		case PPC_ID_PAIREDSINGLE_PS_CMPO0: return "ps_cmpo0";
+		case PPC_ID_PAIREDSINGLE_PS_CMPO1: return "ps_cmpo1";
+		case PPC_ID_PAIREDSINGLE_PS_CMPU0: return "ps_cmpu0";
+		case PPC_ID_PAIREDSINGLE_PS_CMPU1: return "ps_cmpu1";
+		case PPC_ID_PAIREDSINGLE_PS_DIVx: return RcMnemonic(instruction, SubMnemPS_DIVx);
+		case PPC_ID_PAIREDSINGLE_PS_MADDx: return RcMnemonic(instruction, SubMnemPS_MADDx);
+		case PPC_ID_PAIREDSINGLE_PS_MADDS0x: return RcMnemonic(instruction, SubMnemPS_MADDS0x);
+		case PPC_ID_PAIREDSINGLE_PS_MADDS1x: return RcMnemonic(instruction, SubMnemPS_MADDS1x);
+		case PPC_ID_PAIREDSINGLE_PS_MERGE00x: return RcMnemonic(instruction, SubMnemPS_MERGE00x);
+		case PPC_ID_PAIREDSINGLE_PS_MERGE01x: return RcMnemonic(instruction, SubMnemPS_MERGE01x);
+		case PPC_ID_PAIREDSINGLE_PS_MERGE10x: return RcMnemonic(instruction, SubMnemPS_MERGE10x);
+		case PPC_ID_PAIREDSINGLE_PS_MERGE11x: return RcMnemonic(instruction, SubMnemPS_MERGE11x);
+		case PPC_ID_PAIREDSINGLE_PS_MRx: return RcMnemonic(instruction, SubMnemPS_MRx);
+		case PPC_ID_PAIREDSINGLE_PS_MSUBx: return RcMnemonic(instruction, SubMnemPS_MSUBx);
+		case PPC_ID_PAIREDSINGLE_PS_MULx: return RcMnemonic(instruction, SubMnemPS_MULx);
+		case PPC_ID_PAIREDSINGLE_PS_MULS0x: return RcMnemonic(instruction, SubMnemPS_MULS0x);
+		case PPC_ID_PAIREDSINGLE_PS_MULS1x: return RcMnemonic(instruction, SubMnemPS_MULS1x);
+		case PPC_ID_PAIREDSINGLE_PS_NABSx: return RcMnemonic(instruction, SubMnemPS_NABSx);
+		case PPC_ID_PAIREDSINGLE_PS_NEGx: return RcMnemonic(instruction, SubMnemPS_NEGx);
+		case PPC_ID_PAIREDSINGLE_PS_NMADDx: return RcMnemonic(instruction, SubMnemPS_NMADDx);
+		case PPC_ID_PAIREDSINGLE_PS_NMSUBx: return RcMnemonic(instruction, SubMnemPS_NMSUBx);
+		case PPC_ID_PAIREDSINGLE_PS_RESx: return RcMnemonic(instruction, SubMnemPS_RESx);
+		case PPC_ID_PAIREDSINGLE_PS_RSQRTEx: return RcMnemonic(instruction, SubMnemPS_RSQRTEx);
+		case PPC_ID_PAIREDSINGLE_PS_SELx: return RcMnemonic(instruction, SubMnemPS_SELx);
+		case PPC_ID_PAIREDSINGLE_PS_SUBx: return RcMnemonic(instruction, SubMnemPS_SUBx);
+		case PPC_ID_PAIREDSINGLE_PS_SUM0x: return RcMnemonic(instruction, SubMnemPS_SUM0x);
+		case PPC_ID_PAIREDSINGLE_PS_SUM1x: return RcMnemonic(instruction, SubMnemPS_SUM1x);
+		case PPC_ID_PAIREDSINGLE_PSQ_L: return "psq_l";
+		case PPC_ID_PAIREDSINGLE_PSQ_LU: return "psq_lu";
+		case PPC_ID_PAIREDSINGLE_PSQ_LUX: return "psq_lux";
+		case PPC_ID_PAIREDSINGLE_PSQ_LX: return "psq_lx";
+		case PPC_ID_PAIREDSINGLE_PSQ_ST: return "psq_st";
+		case PPC_ID_PAIREDSINGLE_PSQ_STU: return "psq_stu";
+		case PPC_ID_PAIREDSINGLE_PSQ_STUX: return "psq_stux";
+		case PPC_ID_PAIREDSINGLE_PSQ_STX: return "psq_stx";
+
+		case PPC_ID_SPE_BRINC: return "brinc";
+		case PPC_ID_SPE_EFDABS: return "efdabs";
+		case PPC_ID_SPE_EFDADD: return "efdadd";
+		case PPC_ID_SPE_EFDCFS: return "efdcfs";
+		case PPC_ID_SPE_EFDCFSF: return "efdcfsf";
+		case PPC_ID_SPE_EFDCFSI: return "efdcfsi";
+		case PPC_ID_SPE_EFDCFSID: return "efdcfsid";
+		case PPC_ID_SPE_EFDCFUF: return "efdcfuf";
+		case PPC_ID_SPE_EFDCFUI: return "efdcfui";
+		case PPC_ID_SPE_EFDCFUID: return "efdcfuid";
+		case PPC_ID_SPE_EFDCMPEQ: return "efdcmpeq";
+		case PPC_ID_SPE_EFDCMPGT: return "efdcmpgt";
+		case PPC_ID_SPE_EFDCMPLT: return "efdcmplt";
+		case PPC_ID_SPE_EFDCTSF: return "efdctsf";
+		case PPC_ID_SPE_EFDCTSI: return "efdctsi";
+		case PPC_ID_SPE_EFDCTSIDZ: return "efdctsidz";
+		case PPC_ID_SPE_EFDCTSIZ: return "efdctsiz";
+		case PPC_ID_SPE_EFDCTUF: return "efdctuf";
+		case PPC_ID_SPE_EFDCTUI: return "efdctui";
+		case PPC_ID_SPE_EFDCTUIDZ: return "efdctuidz";
+		case PPC_ID_SPE_EFDCTUIZ: return "efdctuiz";
+		case PPC_ID_SPE_EFDDIV: return "efddiv";
+		case PPC_ID_SPE_EFDMUL: return "efdmul";
+		case PPC_ID_SPE_EFDNABS: return "efdnabs";
+		case PPC_ID_SPE_EFDNEG: return "efdneg";
+		case PPC_ID_SPE_EFDSUB: return "efdsub";
+		case PPC_ID_SPE_EFDTSTEQ: return "efdtsteq";
+		case PPC_ID_SPE_EFDTSTGT: return "efdtstgt";
+		case PPC_ID_SPE_EFDTSTLT: return "efdtstlt";
+		case PPC_ID_SPE_EFSABS: return "efsabs";
+		case PPC_ID_SPE_EFSADD: return "efsadd";
+		case PPC_ID_SPE_EFSCFD: return "efscfd";
+		case PPC_ID_SPE_EFSCFSF: return "efscfsf";
+		case PPC_ID_SPE_EFSCFSI: return "efscfsi";
+		case PPC_ID_SPE_EFSCFUF: return "efscfuf";
+		case PPC_ID_SPE_EFSCFUI: return "efscfui";
+		case PPC_ID_SPE_EFSCMPEQ: return "efscmpeq";
+		case PPC_ID_SPE_EFSCMPGT: return "efscmpgt";
+		case PPC_ID_SPE_EFSCMPLT: return "efscmplt";
+		case PPC_ID_SPE_EFSCTSF: return "efsctsf";
+		case PPC_ID_SPE_EFSCTSI: return "efsctsi";
+		case PPC_ID_SPE_EFSCTSIZ: return "efsctsiz";
+		case PPC_ID_SPE_EFSCTUF: return "efsctuf";
+		case PPC_ID_SPE_EFSCTUI: return "efsctui";
+		case PPC_ID_SPE_EFSCTUIZ: return "efsctuiz";
+		case PPC_ID_SPE_EFSDIV: return "efsdiv";
+		case PPC_ID_SPE_EFSMUL: return "efsmul";
+		case PPC_ID_SPE_EFSNABS: return "efsnabs";
+		case PPC_ID_SPE_EFSNEG: return "efsneg";
+		case PPC_ID_SPE_EFSSUB: return "efssub";
+		case PPC_ID_SPE_EFSTSTEQ: return "efststeq";
+		case PPC_ID_SPE_EFSTSTGT: return "efststgt";
+		case PPC_ID_SPE_EFSTSTLT: return "efststlt";
+		case PPC_ID_SPE_EVABS: return "evabs";
+		case PPC_ID_SPE_EVADDIW: return "evaddiw";
+		case PPC_ID_SPE_EVADDSMIAAW: return "evaddsmiaaw";
+		case PPC_ID_SPE_EVADDSSIAAW: return "evaddssiaaw";
+		case PPC_ID_SPE_EVADDUMIAAW: return "evaddumiaaw";
+		case PPC_ID_SPE_EVADDUSIAAW: return "evaddusiaaw";
+		case PPC_ID_SPE_EVADDW: return "evaddw";
+		case PPC_ID_SPE_EVAND: return "evand";
+		case PPC_ID_SPE_EVANDC: return "evandc";
+		case PPC_ID_SPE_EVCMPEQ: return "evcmpeq";
+		case PPC_ID_SPE_EVCMPGTS: return "evcmpgts";
+		case PPC_ID_SPE_EVCMPGTU: return "evcmpgtu";
+		case PPC_ID_SPE_EVCMPLTS: return "evcmplts";
+		case PPC_ID_SPE_EVCMPLTU: return "evcmpltu";
+		case PPC_ID_SPE_EVCNTLSW: return "evcntlsw";
+		case PPC_ID_SPE_EVCNTLZW: return "evcntlzw";
+		case PPC_ID_SPE_EVDIVWS: return "evdivws";
+		case PPC_ID_SPE_EVDIVWU: return "evdivwu";
+		case PPC_ID_SPE_EVEQV: return "eveqv";
+		case PPC_ID_SPE_EVEXTSB: return "evextsb";
+		case PPC_ID_SPE_EVEXTSH: return "evextsh";
+		case PPC_ID_SPE_EVFSABS: return "evfsabs";
+		case PPC_ID_SPE_EVFSADD: return "evfsadd";
+		case PPC_ID_SPE_EVFSCFSF: return "evfscfsf";
+		case PPC_ID_SPE_EVFSCFSI: return "evfscfsi";
+		case PPC_ID_SPE_EVFSCFUF: return "evfscfuf";
+		case PPC_ID_SPE_EVFSCFUI: return "evfscfui";
+		case PPC_ID_SPE_EVSCFUI: return "evscfui";
+		case PPC_ID_SPE_EVFSCMPEQ: return "evfscmpeq";
+		case PPC_ID_SPE_EVFSCMPGT: return "evfscmpgt";
+		case PPC_ID_SPE_EVFSCMPLT: return "evfscmplt";
+		case PPC_ID_SPE_EVFSCTSF: return "evfsctsf";
+		case PPC_ID_SPE_EVFSCTSI: return "evfsctsi";
+		case PPC_ID_SPE_EVFSCTSIZ: return "evfsctsiz";
+		case PPC_ID_SPE_EVFSCTUF: return "evfsctuf";
+		case PPC_ID_SPE_EVFSCTUI: return "evfsctui";
+		case PPC_ID_SPE_EVFSCTUIZ: return "evfsctuiz";
+		case PPC_ID_SPE_EVFSDIV: return "evfsdiv";
+		case PPC_ID_SPE_EVFSMUL: return "evfsmul";
+		case PPC_ID_SPE_EVFSNABS: return "evfsnabs";
+		case PPC_ID_SPE_EVFSNEG: return "evfsneg";
+		case PPC_ID_SPE_EVFSSUB: return "evfssub";
+		case PPC_ID_SPE_EVFSTSTEQ: return "evfststeq";
+		case PPC_ID_SPE_EVFSTSTGT: return "evfststgt";
+		case PPC_ID_SPE_EVFSTSTLT: return "evfststlt";
+		case PPC_ID_SPE_EVLDD: return "evldd";
+		case PPC_ID_SPE_EVLDDX: return "evlddx";
+		case PPC_ID_SPE_EVLDH: return "evldh";
+		case PPC_ID_SPE_EVLDHX: return "evldhx";
+		case PPC_ID_SPE_EVLDW: return "evldw";
+		case PPC_ID_SPE_EVLDWX: return "evldwx";
+		case PPC_ID_SPE_EVLHHESPLAT: return "evlhhesplat";
+		case PPC_ID_SPE_EVLHHESPLATX: return "evlhhesplatx";
+		case PPC_ID_SPE_EVLHHOSSPLAT: return "evlhhossplat";
+		case PPC_ID_SPE_EVLHHOSSPLATX: return "evlhhossplatx";
+		case PPC_ID_SPE_EVLHHOUSPLAT: return "evlhhousplat";
+		case PPC_ID_SPE_EVLHHOUSPLATX: return "evlhhousplatx";
+		case PPC_ID_SPE_EVLWHE: return "evlwhe";
+		case PPC_ID_SPE_EVLWHEX: return "evlwhex";
+		case PPC_ID_SPE_EVLWHOS: return "evlwhos";
+		case PPC_ID_SPE_EVLWHOSX: return "evlwhosx";
+		case PPC_ID_SPE_EVLWHOU: return "evlwhou";
+		case PPC_ID_SPE_EVLWHOUX: return "evlwhoux";
+		case PPC_ID_SPE_EVLWHSPLAT: return "evlwhsplat";
+		case PPC_ID_SPE_EVLWHSPLATX: return "evlwhsplatx";
+		case PPC_ID_SPE_EVLWWSPLAT: return "evlwwsplat";
+		case PPC_ID_SPE_EVLWWSPLATX: return "evlwwsplatx";
+		case PPC_ID_SPE_EVMERGEHI: return "evmergehi";
+		case PPC_ID_SPE_EVMERGEHILO: return "evmergehilo";
+		case PPC_ID_SPE_EVMERGELO: return "evmergelo";
+		case PPC_ID_SPE_EVMERGELOHI: return "evmergelohi";
+		case PPC_ID_SPE_EVMHEGSMFAA: return "evmhegsmfaa";
+		case PPC_ID_SPE_EVMHEGSMFAN: return "evmhegsmfan";
+		case PPC_ID_SPE_EVMHEGSMIAA: return "evmhegsmiaa";
+		case PPC_ID_SPE_EVMHEGSMIAN: return "evmhegsmian";
+		case PPC_ID_SPE_EVMHEGUMIAA: return "evmhegumiaa";
+		case PPC_ID_SPE_EVMHEGUMIAN: return "evmhegumian";
+		case PPC_ID_SPE_EVMHESMF: return "evmhesmf";
+		case PPC_ID_SPE_EVMHESMFA: return "evmhesmfa";
+		case PPC_ID_SPE_EVMHESMFAAW: return "evmhesmfaaw";
+		case PPC_ID_SPE_EVMHESMFANW: return "evmhesmfanw";
+		case PPC_ID_SPE_EVMHESMI: return "evmhesmi";
+		case PPC_ID_SPE_EVMHESMIA: return "evmhesmia";
+		case PPC_ID_SPE_EVMHESMIAAW: return "evmhesmiaaw";
+		case PPC_ID_SPE_EVMHESMIANW: return "evmhesmianw";
+		case PPC_ID_SPE_EVMHESSF: return "evmhessf";
+		case PPC_ID_SPE_EVMHESSFA: return "evmhessfa";
+		case PPC_ID_SPE_EVMHESSFAAW: return "evmhessfaaw";
+		case PPC_ID_SPE_EVMHESSFANW: return "evmhessfanw";
+		case PPC_ID_SPE_EVMHESSIAAW: return "evmhessiaaw";
+		case PPC_ID_SPE_EVMHESSIANW: return "evmhessianw";
+		case PPC_ID_SPE_EVMHEUMI: return "evmheumi";
+		case PPC_ID_SPE_EVMHEUMIA: return "evmheumia";
+		case PPC_ID_SPE_EVMHEUMIAAW: return "evmheumiaaw";
+		case PPC_ID_SPE_EVMHEUMIANW: return "evmheumianw";
+		case PPC_ID_SPE_EVMHEUSIAAW: return "evmheusiaaw";
+		case PPC_ID_SPE_EVMHEUSIANW: return "evmheusianw";
+		case PPC_ID_SPE_EVMHOGSMFAA: return "evmhogsmfaa";
+		case PPC_ID_SPE_EVMHOGSMFAN: return "evmhogsmfan";
+		case PPC_ID_SPE_EVMHOGSMIAA: return "evmhogsmiaa";
+		case PPC_ID_SPE_EVMHOGSMIAN: return "evmhogsmian";
+		case PPC_ID_SPE_EVMHOGUMIAA: return "evmhogumiaa";
+		case PPC_ID_SPE_EVMHOGUMIAN: return "evmhogumian";
+		case PPC_ID_SPE_EVMHOSMF: return "evmhosmf";
+		case PPC_ID_SPE_EVMHOSMFA: return "evmhosmfa";
+		case PPC_ID_SPE_EVMHOSMFAAW: return "evmhosmfaaw";
+		case PPC_ID_SPE_EVMHOSMFANW: return "evmhosmfanw";
+		case PPC_ID_SPE_EVMHOSMI: return "evmhosmi";
+		case PPC_ID_SPE_EVMHOSMIA: return "evmhosmia";
+		case PPC_ID_SPE_EVMHOSMIAAW: return "evmhosmiaaw";
+		case PPC_ID_SPE_EVMHOSMIANW: return "evmhosmianw";
+		case PPC_ID_SPE_EVMHOSSF: return "evmhossf";
+		case PPC_ID_SPE_EVMHOSSFA: return "evmhossfa";
+		case PPC_ID_SPE_EVMHOSSFAAW: return "evmhossfaaw";
+		case PPC_ID_SPE_EVMHOSSFANW: return "evmhossfanw";
+		case PPC_ID_SPE_EVMHOSSIAAW: return "evmhossiaaw";
+		case PPC_ID_SPE_EVMHOSSIANW: return "evmhossianw";
+		case PPC_ID_SPE_EVMHOUMI: return "evmhoumi";
+		case PPC_ID_SPE_EVMHOUMIA: return "evmhoumia";
+		case PPC_ID_SPE_EVMHOUMIAAW: return "evmhoumiaaw";
+		case PPC_ID_SPE_EVMHOUMIANW: return "evmhoumianw";
+		case PPC_ID_SPE_EVMHOUSIAAW: return "evmhousiaaw";
+		case PPC_ID_SPE_EVMHOUSIANW: return "evmhousianw";
+		case PPC_ID_SPE_EVMR: return "evmr";
+		case PPC_ID_SPE_EVMRA: return "evmra";
+		case PPC_ID_SPE_EVMWHSMF: return "evmwhsmf";
+		case PPC_ID_SPE_EVMWHSMFA: return "evmwhsmfa";
+		case PPC_ID_SPE_EVMWHSMI: return "evmwhsmi";
+		case PPC_ID_SPE_EVMWHSMIA: return "evmwhsmia";
+		case PPC_ID_SPE_EVMWHSSF: return "evmwhssf";
+		case PPC_ID_SPE_EVMWHSSFA: return "evmwhssfa";
+		case PPC_ID_SPE_EVMWHUMI: return "evmwhumi";
+		case PPC_ID_SPE_EVMWHUMIA: return "evmwhumia";
+		case PPC_ID_SPE_EVMWHUSIAAW: return "evmwhusiaaw";
+		case PPC_ID_SPE_EVMWHUSIANW: return "evmwhusianw";
+		case PPC_ID_SPE_EVMWLSMIAAW: return "evmwlsmiaaw";
+		case PPC_ID_SPE_EVMWLSMIANW: return "evmwlsmianw";
+		case PPC_ID_SPE_EVMWLSSIANW: return "evmwlssianw";
+		case PPC_ID_SPE_EVMWLSSIAAW: return "evmwlssiaaw";
+		case PPC_ID_SPE_EVMWLUMI: return "evmwlumi";
+		case PPC_ID_SPE_EVMWLUMIA: return "evmwlumia";
+		case PPC_ID_SPE_EVMWLUMIAAW: return "evmwlumiaaw";
+		case PPC_ID_SPE_EVMWLUMIANW: return "evmwlumianw";
+		case PPC_ID_SPE_EVMWLUSIAAW: return "evmwlusiaaw";
+		case PPC_ID_SPE_EVMWLUSIANW: return "evmwlusianw";
+		case PPC_ID_SPE_EVMWSMF: return "evmwsmf";
+		case PPC_ID_SPE_EVMWSMFA: return "evmwsmfa";
+		case PPC_ID_SPE_EVMWSMFAA: return "evmwsmfaa";
+		case PPC_ID_SPE_EVMWSMFAN: return "evmwsmfan";
+		case PPC_ID_SPE_EVMWSMI: return "evmwsmi";
+		case PPC_ID_SPE_EVMWSMIA: return "evmwsmia";
+		case PPC_ID_SPE_EVMWSMIAA: return "evmwsmiaa";
+		case PPC_ID_SPE_EVMWSMIAN: return "evmwsmian";
+		case PPC_ID_SPE_EVMWSSF: return "evmwssf";
+		case PPC_ID_SPE_EVMWSSFA: return "evmwssfa";
+		case PPC_ID_SPE_EVMWSSFAA: return "evmwssfaa";
+		case PPC_ID_SPE_EVMWSSFAN: return "evmwssfan";
+		case PPC_ID_SPE_EVMWUMI: return "evmwumi";
+		case PPC_ID_SPE_EVMWUMIA: return "evmwumia";
+		case PPC_ID_SPE_EVMWUMIAA: return "evmwumiaa";
+		case PPC_ID_SPE_EVMWUMIAN: return "evmwumian";
+		case PPC_ID_SPE_EVNAND: return "evnand";
+		case PPC_ID_SPE_EVNEG: return "evneg";
+		case PPC_ID_SPE_EVNOR: return "evnor";
+		case PPC_ID_SPE_EVNOT: return "evnot";
+		case PPC_ID_SPE_EVOR: return "evor";
+		case PPC_ID_SPE_EVORC: return "evorc";
+		case PPC_ID_SPE_EVRLW: return "evrlw";
+		case PPC_ID_SPE_EVRLWI: return "evrlwi";
+		case PPC_ID_SPE_EVRNDW: return "evrndw";
+		case PPC_ID_SPE_EVSEL: return "evsel";
+		case PPC_ID_SPE_EVSLW: return "evslw";
+		case PPC_ID_SPE_EVSLWI: return "evslwi";
+		case PPC_ID_SPE_EVSPLATFI: return "evsplatfi";
+		case PPC_ID_SPE_EVSPLATI: return "evsplati";
+		case PPC_ID_SPE_EVSRWIS: return "evsrwis";
+		case PPC_ID_SPE_EVSRWIU: return "evsrwiu";
+		case PPC_ID_SPE_EVSRWS: return "evsrws";
+		case PPC_ID_SPE_EVSRWU: return "evsrwu";
+		case PPC_ID_SPE_EVSTDD: return "evstdd";
+		case PPC_ID_SPE_EVSTDDX: return "evstddx";
+		case PPC_ID_SPE_EVSTDH: return "evstdh";
+		case PPC_ID_SPE_EVSTDHX: return "evstdhx";
+		case PPC_ID_SPE_EVSTDW: return "evstdw";
+		case PPC_ID_SPE_EVSTDWX: return "evstdwx";
+		case PPC_ID_SPE_EVSTWHE: return "evstwhe";
+		case PPC_ID_SPE_EVSTWHEX: return "evstwhex";
+		case PPC_ID_SPE_EVSTWHO: return "evstwho";
+		case PPC_ID_SPE_EVSTWHOX: return "evstwhox";
+		case PPC_ID_SPE_EVSTWWE: return "evstwwe";
+		case PPC_ID_SPE_EVSTWWEX: return "evstwwex";
+		case PPC_ID_SPE_EVSTWWO: return "evstwwo";
+		case PPC_ID_SPE_EVSTWWOX: return "evstwwox";
+		case PPC_ID_SPE_EVSUBFSMIAAW: return "evsubfsmiaaw";
+		case PPC_ID_SPE_EVSUBFSSIAAW: return "evsubfssiaaw";
+		case PPC_ID_SPE_EVSUBFUMIAAW: return "evsubfumiaaw";
+		case PPC_ID_SPE_EVSUBFUSIAAW: return "evsubfusiaaw";
+		case PPC_ID_SPE_EVSUBFW: return "evsubfw";
+		case PPC_ID_SPE_EVSUBIFW: return "evsubifw";
+		case PPC_ID_SPE_EVXOR: return "evxor";
+
+		case PPC_ID_VLE_E_ADDIx: return RcMnemonic(instruction, SubMnemVle32ADDIx);
+		case PPC_ID_VLE_E_ADDICx: return RcMnemonic(instruction, SubMnemVle32ADDICx);
+		case PPC_ID_VLE_E_ADD2I: return "e_add2i";
+		case PPC_ID_VLE_E_ADD2IS: return "e_add2is";
+		case PPC_ID_VLE_E_ADD16I: return "e_add16i";
+		case PPC_ID_VLE_E_ANDIx: return RcMnemonic(instruction, SubMnemVle32ANDIx);
+		case PPC_ID_VLE_E_AND2I: return "e_and2i";
+		case PPC_ID_VLE_E_AND2IS: return "e_and2is";
+		case PPC_ID_VLE_E_Bx: return LkMnemonic(instruction, SubMnemVle32Bx);
+		case PPC_ID_VLE_E_BCx:
+		{
+			uint32_t bo = instruction->operands[0].uimm;
+			uint32_t bi = instruction->operands[1].uimm;
+
+			switch (bo)
+			{
+				// Branch if false
+				case 0:
+					switch (bi & 0x3)
+					{
+						case 0: return LkMnemonic(instruction, SubMnemVle32BGEx);
+						case 1: return LkMnemonic(instruction, SubMnemVle32BLEx);
+						case 2: return LkMnemonic(instruction, SubMnemVle32BNEx);
+						case 3: return LkMnemonic(instruction, SubMnemVle32BNSx);
+
+						default:
+							return NULL;
+					}
+
+					break;
+
+				// Branch if true
+				case 1:
+					switch (bi & 0x3)
+					{
+						case 0: return LkMnemonic(instruction, SubMnemVle32BLTx);
+						case 1: return LkMnemonic(instruction, SubMnemVle32BGTx);
+						case 2: return LkMnemonic(instruction, SubMnemVle32BEQx);
+						case 3: return LkMnemonic(instruction, SubMnemVle32BSOx);
+
+						default:
+							return NULL;
+					}
+
+					break;
+
+				// Decrement CTR, branch if zero/nonzero
+				// BI doesn't matter
+				case 2: return LkMnemonic(instruction, SubMnemVle32BDNZx);
+				case 3: return LkMnemonic(instruction, SubMnemVle32BDZx);
+
+				// Should be unreachable; bo only 2 bits
+				default:
+					return NULL;
+			}
+		}
+		case PPC_ID_VLE_E_CMP16I: return "e_cmp16i";
+		case PPC_ID_VLE_E_CMPH16I: return "e_cmph16i";
+		case PPC_ID_VLE_E_CMPHL: return "e_cmphl";
+		case PPC_ID_VLE_E_CMPHL16I: return "e_cmphl16i";
+		case PPC_ID_VLE_E_CMPI: return "e_cmpi";
+		case PPC_ID_VLE_E_CMPL16I: return "e_cmpl16i";
+		case PPC_ID_VLE_E_CMPLI: return "e_cmpli";
+		case PPC_ID_VLE_E_CRAND: return "e_crand";
+		case PPC_ID_VLE_E_CRANDC: return "e_crandc";
+		case PPC_ID_VLE_E_CREQV: return "e_creqv";
+		case PPC_ID_VLE_E_CRNAND: return "e_crnand";
+		case PPC_ID_VLE_E_CRNOR: return "e_crnor";
+		case PPC_ID_VLE_E_CROR: return "e_cror";
+		case PPC_ID_VLE_E_CRORC: return "e_crorc";
+		case PPC_ID_VLE_E_CRXOR: return "e_crxor";
+		case PPC_ID_VLE_E_LBZ: return "e_lbz";
+		case PPC_ID_VLE_E_LBZU: return "e_lbzu";
+		case PPC_ID_VLE_E_LHA: return "e_lha";
+		case PPC_ID_VLE_E_LHAU: return "e_lhau";
+		case PPC_ID_VLE_E_LHZ: return "e_lhz";
+		case PPC_ID_VLE_E_LHZU: return "e_lhzu";
+		case PPC_ID_VLE_E_LI: return "e_li";
+		case PPC_ID_VLE_E_LIS: return "e_lis";
+		case PPC_ID_VLE_E_LMW: return "e_lmw";
+		case PPC_ID_VLE_E_LWZ: return "e_lwz";
+		case PPC_ID_VLE_E_LWZU: return "e_lwzu";
+		case PPC_ID_VLE_E_MCRF: return "e_mcrf";
+		case PPC_ID_VLE_E_MULL2I: return "e_mull2i";
+		case PPC_ID_VLE_E_MULLI: return "e_mulli";
+		case PPC_ID_VLE_E_OR2I: return "e_or2i";
+		case PPC_ID_VLE_E_OR2IS: return "e_or2is";
+		case PPC_ID_VLE_E_ORIx: return RcMnemonic(instruction, SubMnemVle32ORIx);
+		case PPC_ID_VLE_E_RLWx: return RcMnemonic(instruction, SubMnemVle32RLWx);
+		case PPC_ID_VLE_E_RLWIx: return RcMnemonic(instruction, SubMnemVle32RLWIx);
+		case PPC_ID_VLE_E_RLWIMI: return "e_rlwimi";
+		case PPC_ID_VLE_E_RLWINM: return "e_rlwinm";
+		case PPC_ID_VLE_E_SLWIx: return RcMnemonic(instruction, SubMnemVle32SLWIx);
+		case PPC_ID_VLE_E_SRWIx: return RcMnemonic(instruction, SubMnemVle32SRWIx);
+		case PPC_ID_VLE_E_STB: return "e_stb";
+		case PPC_ID_VLE_E_STBU: return "e_stbu";
+		case PPC_ID_VLE_E_STH: return "e_sth";
+		case PPC_ID_VLE_E_STHU: return "e_sthu";
+		case PPC_ID_VLE_E_STMW: return "e_stmw";
+		case PPC_ID_VLE_E_STW: return "e_stw";
+		case PPC_ID_VLE_E_STWU: return "e_stwu";
+		case PPC_ID_VLE_E_SUBFICx: return RcMnemonic(instruction, SubMnemVle32SUBFICx);
+		case PPC_ID_VLE_E_XORIx: return RcMnemonic(instruction, SubMnemVle32XORIx);
+
+		case PPC_ID_VLE_E_LDVGPRW: return "e_ldvgprw";
+		case PPC_ID_VLE_E_LDVSPRW: return "e_ldvsprw";
+		case PPC_ID_VLE_E_LDVSRRW: return "e_ldvsrrw";
+		case PPC_ID_VLE_E_LDVCSRRW: return "e_ldvcsrrw";
+		case PPC_ID_VLE_E_LDVDSRRW: return "e_ldvdsrrw";
+		case PPC_ID_VLE_E_STMVGPRW: return "e_stmvgprw";
+		case PPC_ID_VLE_E_STMVSPRW: return "e_stmvsprw";
+		case PPC_ID_VLE_E_STMVSRRW: return "e_stmvsrrw";
+		case PPC_ID_VLE_E_STMVCSRRW: return "e_stmvcsrrw";
+		case PPC_ID_VLE_E_STMVDSRRW: return "e_stmvdsrrw";
+
+		case PPC_ID_VLE_SE_ADD: return "se_add";
+		case PPC_ID_VLE_SE_ADDI: return "se_addi";
+		case PPC_ID_VLE_SE_ANDx: return RcMnemonic(instruction, SubMnemVle16ANDx);
+		case PPC_ID_VLE_SE_ANDC: return "se_andc";
+		case PPC_ID_VLE_SE_ANDI: return "se_andi";
+		case PPC_ID_VLE_SE_Bx: return LkMnemonic(instruction, SubMnemVle16Bx);
+		case PPC_ID_VLE_SE_BC:
+		{
+			uint32_t bo = instruction->operands[0].uimm;
+			uint32_t bi = instruction->operands[1].uimm;
+
+			switch (bo)
+			{
+				// Branch if false
+				case 0:
+					switch (bi & 0x3)
+					{
+						case 0: return "bgex";
+						case 1: return "blex";
+						case 2: return "bnex";
+						case 3: return "bnsx";
+
+						default:
+							return NULL;
+					}
+
+					break;
+
+				// Branch if true
+				case 1:
+					switch (bi & 0x3)
+					{
+						case 0: return "bltx";
+						case 1: return "bgtx";
+						case 2: return "beqx";
+						case 3: return "bsox";
+
+						default:
+							return NULL;
+					}
+
+					break;
+
+				// Should be unreachable; bo only 1 bit
+				default:
+					return NULL;
+			}
+		}
+		case PPC_ID_VLE_SE_BCLRI: return "se_bclri";
+		case PPC_ID_VLE_SE_BCTRx: return LkMnemonic(instruction, SubMnemVle16BCTRx);
+		case PPC_ID_VLE_SE_BGENI: return "se_bgeni";
+		case PPC_ID_VLE_SE_BLRx: return LkMnemonic(instruction, SubMnemVle16BLRx);
+		case PPC_ID_VLE_SE_BMASKI: return "se_bmaski";
+		case PPC_ID_VLE_SE_BSETI: return "se_bseti";
+		case PPC_ID_VLE_SE_BTSTI: return "se_btsti";
+		case PPC_ID_VLE_SE_CMP: return "se_cmp";
+		case PPC_ID_VLE_SE_CMPH: return "se_cmph";
+		case PPC_ID_VLE_SE_CMPHL: return "se_cmphl";
+		case PPC_ID_VLE_SE_CMPI: return "se_cmpi";
+		case PPC_ID_VLE_SE_CMPL: return "se_cmpl";
+		case PPC_ID_VLE_SE_CMPLI: return "se_cmpli";
+		case PPC_ID_VLE_SE_EXTSB: return "se_extsb";
+		case PPC_ID_VLE_SE_EXTSH: return "se_extsh";
+		case PPC_ID_VLE_SE_EXTZB: return "se_extzb";
+		case PPC_ID_VLE_SE_EXTZH: return "se_extzh";
+		case PPC_ID_VLE_SE_ILLEGAL: return "se_illegal";
+		case PPC_ID_VLE_SE_ISYNC: return "se_isync";
+		case PPC_ID_VLE_SE_LBZ: return "se_lbz";
+		case PPC_ID_VLE_SE_LHZ: return "se_lhz";
+		case PPC_ID_VLE_SE_LI: return "se_li";
+		case PPC_ID_VLE_SE_LWZ: return "se_lwz";
+		case PPC_ID_VLE_SE_MFAR: return "se_mfar";
+		case PPC_ID_VLE_SE_MFCTR: return "se_mfctr";
+		case PPC_ID_VLE_SE_MFLR: return "se_mflr";
+		case PPC_ID_VLE_SE_MR: return "se_mr";
+		case PPC_ID_VLE_SE_MTAR: return "se_mtar";
+		case PPC_ID_VLE_SE_MTCTR: return "se_mtctr";
+		case PPC_ID_VLE_SE_MTLR: return "se_mtlr";
+		case PPC_ID_VLE_SE_MULLW: return "se_mullw";
+		case PPC_ID_VLE_SE_NEG: return "se_neg";
+		case PPC_ID_VLE_SE_NOP: return "se_nop";
+		case PPC_ID_VLE_SE_NOT: return "se_not";
+		case PPC_ID_VLE_SE_OR: return "se_or";
+		case PPC_ID_VLE_SE_RFCI: return "se_rfci";
+		case PPC_ID_VLE_SE_RFDI: return "se_rfdi";
+		case PPC_ID_VLE_SE_RFI: return "se_rfi";
+		case PPC_ID_VLE_SE_RFMCI: return "se_rfmci";
+		case PPC_ID_VLE_SE_SC: return "se_sc";
+		case PPC_ID_VLE_SE_SLW: return "se_slw";
+		case PPC_ID_VLE_SE_SLWI: return "se_slwi";
+		case PPC_ID_VLE_SE_SRAW: return "se_sraw";
+		case PPC_ID_VLE_SE_SRAWI: return "se_srawi";
+		case PPC_ID_VLE_SE_SRW: return "se_srw";
+		case PPC_ID_VLE_SE_SRWI: return "se_srwi";
+		case PPC_ID_VLE_SE_STB: return "se_stb";
+		case PPC_ID_VLE_SE_STH: return "se_sth";
+		case PPC_ID_VLE_SE_STW: return "se_stw";
+		case PPC_ID_VLE_SE_SUB: return "se_sub";
+		case PPC_ID_VLE_SE_SUBF: return "se_subf";
+		case PPC_ID_VLE_SE_SUBIx: return RcMnemonic(instruction, SubMnemVle16SUBIx);
+
+		default: return NULL;
+	}
+}