ARM_ret:                "Return from Subroutine"
ARM_nop:                "No Operation"
ARM_b:                  "Branch"
ARM_bl:                 "Branch with Link"
ARM_asr:                "Arithmetic Shift Right"
ARM_lsl:                "Logical Shift Left"
ARM_lsr:                "Logical Shift Right"
ARM_ror:                "Rotate Right"
ARM_neg:                "Negate"
ARM_and:                "Rd = Op1 & Op2"
ARM_eor:                "Rd = Op1 ^ Op2"
ARM_sub:                "Rd = Op1 - Op2"
ARM_rsb:                "Rd = Op2 - Op1"
ARM_add:                "Rd = Op1 + Op2"
ARM_adc:                "Rd = Op1 + Op2 + C"
ARM_sbc:                "Rd = Op1 - Op2 + C - 1"
ARM_rsc:                "Rd = Op2 - Op1 + C - 1"
ARM_tst:                "Set cond. codes on Op1 & Op2"
ARM_teq:                "Set cond. codes on Op1 ^ Op2"
ARM_cmp:                "Set cond. codes on Op1 - Op2"
ARM_cmn:                "Set cond. codes on Op1 + Op2"
ARM_orr:                "Rd = Op1 | Op2"
ARM_mov:                "Rd = Op2"
ARM_bic:                "Rd = Op1 & ~Op2"
ARM_mvn:                "Rd = ~Op2"
ARM_mrs:                "Transfer PSR to Register"
ARM_msr:                "Transfer Register to PSR"
ARM_mul:                "Multiply"
ARM_mla:                "Multiply-Accumulate"
ARM_ldr:                "Load from Memory"
ARM_ldrpc:              "Indirect Jump"
ARM_str:                "Store to Memory"
ARM_ldm:                "Load Block from Memory"
ARM_stm:                "Store Block to Memory"
ARM_swp:                "Single Data Swap"
ARM_svc:                "Supervisor Call"
ARM_smull:              "Signed Multiply long"
ARM_smlal:              "Signed Multiply-Accumulate long"
ARM_umull:              "Unsigned Multiply long"
ARM_umlal:              "Unsigned Multiply-Accumulate long"
ARM_bx:                 "Branch to/from Thumb mode"
ARM_pop:                "Pop registers"
ARM_push:               "Push registers"
ARM_adr:                "Load address"
ARM_bkpt: { op1 ?       // breakpoints
  0xDEFB: { filetype ?
    f_PE || f_COFF:     "__fastfail(R0)"
    other:              "Breakpoint"
    }
  other:                "Breakpoint"
  }

ARM_blx1:               "Branch with Link and Exchange (immediate address)"
ARM_blx2:               "Branch with Link and Exchange (register indirect)"
ARM_clz:                "Count Leading Zeros"

// Version 5E

ARM_ldrd:               "Load pair of registers"
ARM_pld:                "Prepare to load data"
ARM_qadd:               "Saturated addition"
ARM_qdadd:              "Saturated addition with doubling"
ARM_qdsub:              "Saturated subtraction with doubling"
ARM_qsub:               "Saturated subtraction"
ARM_smlabb:             "Signed multiply-accumulate (bottom*bottom)"
ARM_smlatb:             "Signed multiply-accumulate (top*bottom)"
ARM_smlabt:             "Signed multiply-accumulate (bottom*top)"
ARM_smlatt:             "Signed multiply-accumulate (top*top)"
ARM_smlalbb:            "Long signed multiply-accumulate (bottom*bottom)"
ARM_smlaltb:            "Long signed multiply-accumulate (top*bottom)"
ARM_smlalbt:            "Long signed multiply-accumulate (bottom*top)"
ARM_smlaltt:            "Long signed multiply-accumulate (top*top)"
ARM_smlawb:             "Wide signed multiply-accumulate (bottom)"
ARM_smulwb:             "Wide signed multiply (bottom)"
ARM_smlawt:             "Wide signed multiply-accumulate (top)"
ARM_smulwt:             "Wide signed multiply (top)"
ARM_smulbb:             "Signed multiply (bottom*bottom)"
ARM_smultb:             "Signed multiply (top*bottom)"
ARM_smulbt:             "Signed multiply (bottom*top)"
ARM_smultt:             "Signed multiply (top*top)"
ARM_strd:               "Store pair of registers"

// Intel xScale coprocessor instructions

xScale_mia:             "Multiply-Internal Accumulate"
xScale_miaph:           "Multiply-Internal Accumulate Packed HalfWords"
xScale_miabb:           "Multiply-Internal Accumulate Bottom-Bottom Halves"
xScale_miabt:           "Multiply-Internal Accumulate Bottom-Top Halves"
xScale_miatb:           "Multiply-Internal Accumulate Top-Bottom Halves"
xScale_miatt:           "Multiply-Internal Accumulate Top-Top Halves"
xScale_mar:             "Move To Internal Accumulator"
xScale_mra:             "Move From Internal Accumulator"

// Coprocessor instructions

ARM_cdp:                "Coprocessor Data Processing"
ARM_cdp2:               "Coprocessor Data Processing"
ARM_ldc:                "Load Coprocessor Register"
ARM_ldc2:               "Load Coprocessor Register"
ARM_stc:                "Store Coprocessor Register"
ARM_stc2:               "Store Coprocessor Register"
ARM_mrc:                "Move from Coprocessor to ARM Register"
ARM_mrc2:               "Move from Coprocessor to ARM Register"
ARM_mcr:                "Move from ARM to Coprocessor Register"
ARM_mcr2:               "Move from ARM to Coprocessor Register"
ARM_mcrr:               "Copy pair of registers to coprocessor"
ARM_mrrc:               "Copy pair of registers from coprocessor"

// VFP instructions

ARM_fabsd:              "Floating point Absolute Value, Double precision"
ARM_fabss:              "Floating point Absolute Value, Single precision"
ARM_faddd:              "Floating point Addition, Double precision"
ARM_fadds:              "Floating point Addition, Single precision"
ARM_fcmpd:              "Floating point Compare, Double precision"
ARM_fcmps:              "Floating point Compare, Single precision"
ARM_fcmped:             "Floating point Compare (NaN Exceptions), Double precision"
ARM_fcmpes:             "Floating point Compare (NaN Exceptions), Single precision"
ARM_fcmpezd:            "Floating point Compare (NaN Exceptions) with Zero, Double precision"
ARM_fcmpezs:            "Floating point Compare (NaN Exceptions) with Zero, Single precision"
ARM_fcmpzd:             "Floating point Compare with Zero, Double precision"
ARM_fcmpzs:             "Floating point Compare with Zero, Single precision"
ARM_fcpyd:              "Floating point Copy, Double precision"
ARM_fcpys:              "Floating point Copy, Single precision"
ARM_fcvtsd:             "Floating point Convert to Single precision from Double precision"
ARM_fcvtds:             "Floating point Convert to Double precision from Single precision"
ARM_fdivd:              "Floating point Divide, Double precision"
ARM_fdivs:              "Floating point Divide, Single precision"
ARM_fldd:               "Floating point Load, Double precision"
ARM_flds:               "Floating point Load, Single precision"
ARM_fldmd:              "Floating point Load Multiple, Double precision"
ARM_fldms:              "Floating point Load Multiple, Single precision"
ARM_fldmx:              "Floating point Load Multiple, Unknown precision"
ARM_fmacd:              "Floating point Multiply and Accumulate, Double precision"
ARM_fmacs:              "Floating point Multiply and Accumulate, Single precision"
ARM_fmscd:              "Floating point Multiply and Subtract, Double precision"
ARM_fmscs:              "Floating point Multiply and Subtract, Single precision"
ARM_fmstat:             "Floating point Move Status"
ARM_fmuld:              "Floating point Multiply, Double precision"
ARM_fmuls:              "Floating point Multiply, Single precision"
ARM_fnegd:              "Floating point Negate, Double precision"
ARM_fnegs:              "Floating point Negate, Single precision"
ARM_fnmacd:             "Floating point Negated Multiply and Accumulate, Double precision"
ARM_fnmacs:             "Floating point Negated Multiply and Accumulate, Single precision"
ARM_fnmscd:             "Floating point Negated Multiply and Subtract, Double precision"
ARM_fnmscs:             "Floating point Negated Multiply and Subtract, Single precision"
ARM_fnmuld:             "Floating point Negated Multiply, Double precision"
ARM_fnmuls:             "Floating point Negated Multiply, Single precision"
ARM_fsitod:             "Floating point Convert Signed Integer to Double precision"
ARM_fsitos:             "Floating point Convert Signed Integer to Single precision"
ARM_fsqrtd:             "Floating point Square Root, Double precision"
ARM_fsqrts:             "Floating point Square Root, Single precision"
ARM_fstd:               "Floating point Store, Double precision"
ARM_fsts:               "Floating point Store, Single precision"
ARM_fstmd:              "Floating point Store Multiple, Double precision"
ARM_fstms:              "Floating point Store Multiple, Single precision"
ARM_fstmx:              "Floating point Store Multiple, Unknown precision"
ARM_fsubd:              "Floating point Subtract, Double precision"
ARM_fsubs:              "Floating point Subtract, Single precision"
ARM_ftosid:             "Floating point Convert to Signed Integer from Double precision"
ARM_ftosis:             "Floating point Convert to Signed Integer from Single precision"
ARM_ftosizd:            "Floating point Convert to Signed Integer from Double precision, RZ mode"
ARM_ftosizs:            "Floating point Convert to Signed Integer from Single precision, RZ mode"
ARM_ftouid:             "Floating point Convert to Unsigned Integer from Double precision"
ARM_ftouis:             "Floating point Convert to Unsigned Integer from Single precision"
ARM_ftouizd:            "Floating point Convert to Unsigned Integer from Double precision, RZ mode"
ARM_ftouizs:            "Floating point Convert to Unsigned Integer from Single precision, RZ mode"
ARM_fuitod:             "Floating point Convert Unsigned Integer to Double precision"
ARM_fuitos:             "Floating point Convert Unsigned Integer to Single precision"
ARM_fmdhr:              "Floating point Move to Double precision High from Register"
ARM_fmrdh:              "Floating point Move to Register from Double precision High"
ARM_fmdlr:              "Floating point Move to Double precision Low from Register"
ARM_fmrdl:              "Floating point Move to Register from Double precision Low"
ARM_fmxr:               "Floating point Move to System Register from Register"
ARM_fmrx:               "Floating point Move to Register from System Register"
ARM_fmsr:               "Floating point Move to Single precision from Register"
ARM_fmrs:               "Floating point Move to Register from Single precision"

// VFP ARMv5TE extensions

ARM_fmdrr:              "Floating point Move to Double precision from two Registers"
ARM_fmrrd:              "Floating point Move to two Registers from Double precision"
ARM_fmsrr:              "Floating point Move to two Single precision from two Registers"
ARM_fmrrs:              "Floating point Move to two Registers from two Single precision"

// ARM v5J instructions

ARM_bxj:                "Branch to Jazelle"

// ARM v6 instructions

ARM_mcrr2:              "Move to Coprocessor from two ARM Registers"
ARM_mrrc2:              "Move to two ARM Registers from Coprocessor"
ARM_cps:                "Change Processor State"
ARM_cpsid:              "Disable Interrupts"
ARM_cpsie:              "Enable Interrupts"
ARM_ldrex:              "Load Register Exclusive"
ARM_pkhbt:              "Pack halfword bottom + top"
ARM_pkhtb:              "Pack halfword top + bottom"
ARM_qadd16:             "Signed saturating arithmetic hafword-wise addition"
ARM_qadd8:              "Signed saturating arithmetic byte-wise addition"
ARM_qaddsubx:           "Signed saturating arithmetic exchange, add, substract"
ARM_qsub16:             "Signed saturating arithmetic hafword-wise substraction"
ARM_qsub8:              "Signed saturating arithmetic byte-wise substraction"
ARM_qsubaddx:           "Signed saturating arithmetic exchange, substract, add"
ARM_rev:                "Byte Reverse Word"
ARM_rev16:              "Byte Reverse Packed Halfword"
ARM_revsh:              "Byte Reverse Signed Halfword"
ARM_rfe:                "Return from exception"
ARM_sadd16:             "Signed arithmetic modulo hafword-wise addition"
ARM_sadd8:              "Signed arithmetic modulo byte-wise addition"
ARM_saddsubx:           "Signed arithmetic modulo exchange, add, substract"
ARM_sel:                "Select bytes"
ARM_setend:             "Set Byte Endianness"
ARM_shadd16:            "Signed arithmetic hafword-wise addition, halving results"
ARM_shadd8:             "Signed arithmetic byte-wise addition, halving results"
ARM_shaddsubx:          "Signed arithmetic exchange, add, substract, halving results"
ARM_shsub16:            "Signed arithmetic hafword-wise substraction, halving results"
ARM_shsub8:             "Signed arithmetic byte-wise substraction, halving results"
ARM_shsubaddx:          "Signed arithmetic exchange, substract, add, halving results"
ARM_smlad:              "Dual signed multiply, add and accumulate"
ARM_smladx:             "Dual signed multiply, add and accumulate crossed"
ARM_smuad:              "Dual signed multiply and add"
ARM_smuadx:             "Dual signed multiply and add crossed"
ARM_smlald:             "Dual signed multiply, add and accumulate long"
ARM_smlaldx:            "Dual signed multiply, add and accumulate long crossed"
ARM_smlsd:              "Dual signed multiply, substract and accumulate"
ARM_smlsdx:             "Dual signed multiply, substract and accumulate crossed"
ARM_smusd:              "Dual signed multiply and substract"
ARM_smusdx:             "Dual signed multiply and substract crossed"
ARM_smlsld:             "Dual signed multiply, substract and accumulate long"
ARM_smlsldx:            "Dual signed multiply, substract and accumulate long crossed"
ARM_smmla:              "Signed most significant word multiply and accumulate truncated"
ARM_smmlar:             "Signed most significant word multiply and accumulate rounded"
ARM_smmul:              "Signed most significant word multiply truncated"
ARM_smmulr:             "Signed most significant word multiply rounded"
ARM_smmls:              "Signed most significant word multiply and substract truncated"
ARM_smmlsr:             "Signed most significant word multiply and substract rounded"
ARM_srs:                "Store Return State"
ARM_ssat:               "Signed Saturate"
ARM_ssat16:             "Signed saturate two halfwords"
ARM_ssub16:             "Signed arithmetic hafword-wise substraction"
ARM_ssub8:              "Signed arithmetic byte-wise substraction"
ARM_ssubaddx:           "Signed arithmetic exchange, substract, add"
ARM_strex:              "Store Register Exclusive"
ARM_sxtab:              "Signed extend byte to word, add"
ARM_sxtb:               "Signed extend byte to word"
ARM_sxtab16:            "Signed extend two bytes to halfwords, add"
ARM_sxtb16:             "Signed extend two bytes to halfwords"
ARM_sxtah:              "Signed extend halfword to word, add"
ARM_sxth:               "Signed extend halfword to word"
ARM_uadd16:             "Unsigned arithmetic modulo hafword-wise addition"
ARM_uadd8:              "Unsigned arithmetic modulo byte-wise addition"
ARM_uaddsubx:           "Unsigned arithmetic modulo exchange, add, substract"
ARM_uhadd16:            "Unsigned arithmetic hafword-wise addition, halving results"
ARM_uhadd8:             "Unsigned arithmetic byte-wise addition, halving results"
ARM_uhaddsubx:          "Unsigned arithmetic exchange, add, substract, halving results"
ARM_uhsub16:            "Unsigned arithmetic hafword-wise substraction, halving results"
ARM_uhsub8:             "Unsigned arithmetic byte-wise substraction, halving results"
ARM_uhsubaddx:          "Unsigned arithmetic exchange, substract, add, halving results"
ARM_umaal:              "Multiply unsigned double accumulate long"
ARM_uqadd16:            "Unsigned saturating arithmetic hafword-wise addition"
ARM_uqadd8:             "Unsigned saturating arithmetic byte-wise addition"
ARM_uqaddsubx:          "Unsigned saturating arithmetic exchange, add, substract"
ARM_uqsub16:            "Unsigned saturating arithmetic hafword-wise substraction"
ARM_uqsub8:             "Unsigned saturating arithmetic byte-wise substraction"
ARM_uqsubaddx:          "Unsigned saturating arithmetic exchange, substract, add"
ARM_usada8:             "Unsigned sum of absolute differences and accumulate"
ARM_usad8:              "Unsigned sum of absolute differences"
ARM_usat:               "Unsigned saturate word"
ARM_usat16:             "Unsigned saturate two halfwords"
ARM_usub16:             "Unsigned arithmetic hafword-wise substraction"
ARM_usub8:              "Unsigned arithmetic byte-wise substraction"
ARM_usubaddx:           "Unsigned arithmetic exchange, substract, add"
ARM_uxtab:              "Unsigned extend byte to word, add"
ARM_uxtb:               "Unsigned extend byte to word"
ARM_uxtab16:            "Unsigned extend two bytes to halfwords, add"
ARM_uxtb16:             "Unsigned extend two bytes to halfwords"
ARM_uxtah:              "Unsigned extend halfword to word, add"
ARM_uxth:               "Unsigned extend halfword to word"

// ARM v6zk instructions

ARM_clrex:              "Clear Exclusive"
ARM_ldrexb:             "Load Byte Exclusive"
ARM_ldrexd:             "Load DoubleWord Exclusive"
ARM_ldrexh:             "Load Halfword Exclusive"
ARM_strexb:             "Store Byte Exclusive"
ARM_strexd:             "Store DoubleWord Exclusive"
ARM_strexh:             "Store Halfword Exclusive"
ARM_yield:              "Yield (hint)"
ARM_sev:                "Send Event (hint)"
ARM_wfe:                "Wait For Event (hint)"
ARM_wfi:                "Wait For Interrupt (hint)"
ARM_smc:                "Secure Monitor Call"

// ARM Thumb32 instructions

ARM_orn:                "Rd = Op1 | ~Op2"
ARM_movt:               "Move Top"
ARM_sbfx:               "Signed Bit Field Extract"
ARM_ubfx:               "Unsigned Bit Field Extract"
ARM_bfi:                "Bit Field Insert"
ARM_bfc:                "Bit Field Clear"
ARM_tbb:                "Table Branch Byte"
ARM_tbh:                "Table Branch Halfword"
ARM_pli:                "Prepare to load code"
ARM_rbit:               "Reverse Bits"
ARM_it:                 "If Then"
ARM_mls:                "Multiply and Subtract"
ARM_sdiv:               "Signed Divide"
ARM_udiv:               "Unsigned Divide"
ARM_cbz:                "Compare and Branch on Zero"
ARM_cbnz:               "Compare and Branch on Non-Zero"
ARM_dsb:                "Data Synchronization Barrier"
ARM_dmb:                "Data Memory Barrier"
ARM_isb:                "Instruction Synchronization Barrier"
ARM_dbg:                "Debug Hint"
ARM_und:                {
  op1 ?
	 0xF9: "Windows on ARM: __brkdiv0"
	 0xFA: "Windows on ARM: __rdpmccntr64"
	 0xFB: "Windows on ARM: __fastfail"
	 0xFC: "Windows on ARM: __assertfail"
	 0xFD: "Windows on ARM: __debugservice"
	 0xFE: "Windows on ARM: __debugbreak"
	other: "Architecturally undefined instruction (always causes the Undefined instruction exception)"
}

// missing instructions (not yet decoded)

ARM_rrx:                "Rotate Right with Extend"
ARM_enterx:             "Enter ThumbEE state"
ARM_leavex:             "Leave ThumbEE state"
ARM_chka:               "Check Array"
ARM_hb:                 "Handler Branch"
ARM_hbl:                "Handler Branch with Link"
ARM_hblp:               "Handler Branch with Link and Parameter"
ARM_hbp:                "Handler Branch with Parameter"

// NEON (Advanced SIMD) and extra VFP instructions

ARM_vaba:               "Vector Absolute Difference and Accumulate"
ARM_vabal:              "Vector Absolute Difference and Accumulate Long"
ARM_vabd:               "Vector Absolute Difference"
ARM_vabdl:              "Vector Absolute Difference Long"
ARM_vabs:               "Vector Absolute"
ARM_vacge:              "Vector Absolute Compare Greater Than or Equal"
ARM_vacgt:              "Vector Absolute Compare Greater Than"
ARM_vacle:              "Vector Absolute Compare Less Than or Equal"
ARM_vaclt:              "Vector Absolute Compare Less Than"
ARM_vadd:               "Vector Add"
ARM_vaddhn:             "Vector Add and Narrow, returning High Half"
ARM_vaddl:              "Vector Add Long"
ARM_vaddw:              "Vector Add Wide"
ARM_vand:               "Vector Bitwise AND"
ARM_vbic:               "Vector Bitwise Bit Clear"
ARM_vbif:               "Vector Bitwise Insert if False"
ARM_vbit:               "Vector Bitwise Insert if True"
ARM_vbsl:               "Vector Bitwise Select"
ARM_vceq:               "Vector Compare Equal"
ARM_vcge:               "Vector Compare Greater Than or Equal"
ARM_vcgt:               "Vector Compare Greater Than"
ARM_vcle:               "Vector Compare Less Than or Equal"
ARM_vcls:               "Vector Count Leading Sign Bits"
ARM_vclt:               "Vector Compare Less Than"
ARM_vclz:               "Vector Count Leading Zeros"
ARM_vcmp:               "Vector Compare"
ARM_vcmpe:              "Vector Compare (Quiet NaNs trigger Exception)"
ARM_vcnt:               "Vector Count Number of Bits"
ARM_vcvt:               "Vector Convert"
ARM_vcvtr:              "Vector Convert Rounding"
ARM_vcvtb:              "Vector Convert Half-Precision Bottom"
ARM_vcvtt:              "Vector Convert Half-Precision Top"
ARM_vdiv:               "Vector Divide"
ARM_vdup:               "Vector Duplicate"
ARM_veor:               "Vector Bitwise Exclusive OR"
ARM_vext:               "Vector Extract"
ARM_vfma:               "Vector Fused Multiply Accumulate"
ARM_vfms:               "Vector Fused Multiply Substract"
ARM_vfnma:              "Vector Fused Negated Multiply Accumulate"
ARM_vfnms:              "Vector Fused Negated Multiply Substract"
ARM_vhadd:              "Vector Halving Add"
ARM_vhsub:              "Vector Halving Sub"
ARM_vld1:               "Vector Load Single Element"
ARM_vld2:               "Vector Load Two-Element Structures"
ARM_vld3:               "Vector Load Three-Element Structures"
ARM_vld4:               "Vector Load Four-Element Structures"
ARM_vldm:               "Vector Load Multiple"
ARM_vldr:               "Vector Load Register"
ARM_vmax:               "Vector Maximum"
ARM_vmin:               "Vector Minimum"
ARM_vmla:               "Vector Multiply Accumulate"
ARM_vmlal:              "Vector Multiply Accumulate Long"
ARM_vmls:               "Vector Multiply Subtract"
ARM_vmlsl:              "Vector Multiply Subtract Long"
ARM_vmov:               "Vector Move"
ARM_vmovl:              "Vector Move Long"
ARM_vmovn:              "Vector Move and Narrow"
ARM_vmrs:               "Move FPSCR to ARM Register"
ARM_vmsr:               "Move to FPSCR from ARM Register "
ARM_vmul:               "Vector Multiply"
ARM_vmull:              "Vector Multiply Long"
ARM_vmvn:               "Vector Bitwise NOT"
ARM_vneg:               "Vector Negate"
ARM_vnmla:              "Vector Multiply Add Negated"
ARM_vnmls:              "Vector Multiply Substract Negated"
ARM_vnmul:              "Vector Multiply Negated"
ARM_vorn:               "Vector Bitwise OR NOT"
ARM_vorr:               "Vector Bitwise OR"
ARM_vpadal:             "Vector Pairwise Add and Accumulate Long"
ARM_vpadd:              "Vector Pairwise Add"
ARM_vpaddl:             "Vector Pairwise Add Long"
ARM_vpmax:              "Vector Pairwise Maximum"
ARM_vpmin:              "Vector Pairwise Minimum"
ARM_vpop:               "Vector Pop"
ARM_vpush:              "Vector Push"
ARM_vqabs:              "Vector Saturating Absolute"
ARM_vqadd:              "Vector Saturating Add"
ARM_vqdmlal:            "Vector Saturating Doubling Multiply Accumulate Long"
ARM_vqdmlsl:            "Vector Saturating Doubling Multiply Subtract Long"
ARM_vqdmulh:            "Vector Saturating Doubling Multiply Returning High Half"
ARM_vqdmull:            "Vector Saturating Doubling Multiply Long"
ARM_vqmovn:             "Vector Saturating Move and Narrow"
ARM_vqmovun:            "Vector Saturating Move and Narrow, Unsigned result"
ARM_vqneg:              "Vector Saturating Negate"
ARM_vqrdmulh:           "Vector Saturating Rounding Doubling Multiply Returning High Half"
ARM_vqrshl:             "Vector Saturating Rounding Shift Left"
ARM_vqrshrn:            "Vector Saturating Rounding Shift Right, Narrow"
ARM_vqrshrun:           "Vector Saturating Rounding Shift Right, Narrow, Unsigned result"
ARM_vqshl:              "Vector Saturating Shift Left"
ARM_vqshlu:             "Vector Saturating Shift Left, Unsigned result"
ARM_vqshrn:             "Vector Saturating Shift Right, Narrow"
ARM_vqshrun:            "Vector Saturating Shift Right, Narrow, Unsigned result"
ARM_vqsub:              "Vector Saturating Subtract"
ARM_vraddhn:            "Vector Rounding Add and Narrow, returning High Half"
ARM_vrecpe:             "Vector Reciprocal Estimate"
ARM_vrecps:             "Vector Reciprocal Step"
ARM_vrev16:             "Vector Reverse in halfwords"
ARM_vrev32:             "Vector Reverse in words"
ARM_vrev64:             "Vector Reverse in doublewords"
ARM_vrhadd:             "Vector Rounding Halving Add"
ARM_vrshl:              "Vector Rounding Shift Left"
ARM_vrshr:              "Vector Rounding Shift Right"
ARM_vrshrn:             "Vector Rounding Shift Right and Narrow"
ARM_vrsqrte:            "Vector Reciprocal Square Root Estimate"
ARM_vrsqrts:            "Vector Reciprocal Square Root Step"
ARM_vrsra:              "Vector Rounding Shift Right and Accumulate"
ARM_vrsubhn:            "Vector Rounding Subtract and Narrow, returning High Half"
ARM_vshl:               "Vector Shift Left"
ARM_vshll:              "Vector Shift Left Long"
ARM_vshr:               "Vector Shift Right"
ARM_vshrn:              "Vector Shift Right Narrow"
ARM_vsli:               "Vector Shift Left and Insert"
ARM_vsqrt:              "Vector Square Root"
ARM_vsra:               "Vector Shift Right and Accumulate"
ARM_vsri:               "Vector Shift Right and Insert"
ARM_vst1:               "Vector Store Single Element"
ARM_vst2:               "Vector Store Two-Element Structures"
ARM_vst3:               "Vector Store Three-Element Structures"
ARM_vst4:               "Vector Store Four-Element Structures"
ARM_vstm:               "Vector Store Multiple"
ARM_vstr:               "Vector Store Register"
ARM_vsub:               "Vector Subtract"
ARM_vsubhn:             "Vector Subtract and Narrow, returning High Half"
ARM_vsubl:              "Vector Subtract Long"
ARM_vsubw:              "Vector Subtract Wide"
ARM_vswp:               "Vector Swap"
ARM_vtbl:               "Vector Table Lookup"
ARM_vtbx:               "Vector Table Extension"
ARM_vtrn:               "Vector Transpose"
ARM_vtst:               "Vector Test Bits"
ARM_vuzp:               "Vector Unzip"
ARM_vzip:               "Vector Zip"

// ARMv7 Hypervisor extensions

ARM_eret:               "Exception Return"
ARM_hvc:                "Hypervisor Call"

// new ARMv8 instructions for A32 and T32 mode

ARM_lda:                "Load-Acquire Word/Byte/Halfword"
ARM_stl:                "Store-Release Word/Byte/Halfword"
ARM_ldaex:              "Load-Acquire Exclusive Word/Byte/Halfword"
ARM_stlex:              "Store-Release Exclusive Word/Byte/Halfword"
ARM_vsel:               "Floating-point Conditional Select"

ARM_vmaxnm:             "Vector Maximum Numeric"
ARM_vminnm:             "Vector Minimum Numeric"
ARM_vcvta:              "Vector Convert Round to Nearest with Ties to Away"
ARM_vcvtn:              "Vector Convert Round to Nearest with Ties to Even"
ARM_vcvtp:              "Vector Convert Round towards +Infinity"
ARM_vcvtm:              "Vector Convert Round towards -Infinity"
ARM_vrintx:             "Vector Round to Integral, FPSCR rounding mode and signaling inexactness"
ARM_vrintr:             "Vector Round to Integral, FPSCR rounding mode"
ARM_vrintz:             "Vector Round to Integral, Round toward Zero"
ARM_vrinta:             "Vector Round to Integral, Round to Nearest with Ties to Away"
ARM_vrintn:             "Vector Round to Integral, Round to Nearest with Ties to Even"
ARM_vrintp:             "Vector Round to Integral, Round towards +Infinity"
ARM_vrintm:             "Vector Round to Integral, Round towards -Infinity"

ARM_aesd:               "AES single round decryption"
ARM_aese:               "AES single round encryption"
ARM_aesimc:             "AES inverse mix columns"
ARM_aesmc:              "AES mix columns"
ARM_sha1c:              "SHA1 hash update accelerator, choose"
ARM_sha1m:              "SHA1 hash update accelerator, majority"
ARM_sha1p:              "SHA1 hash update accelerator, parity"
ARM_sha1h:              "SHA1 hash update accelerator, rotate left by 30"
ARM_sha1su0:            "SHA1 schedule update accelerator, first part"
ARM_sha1su1:            "SHA1 schedule update accelerator, second part"
ARM_sha256h:            "SHA256 hash update accelerator"
ARM_sha256h2:           "SHA256 hash update accelerator upper part"
ARM_sha256su0:          "SHA256 schedule update accelerator, first part"
ARM_sha256su1:          "SHA256 schedule update accelerator, second part"

ARM_dcps1:              "Debug Change Processor State to EL1"
ARM_dcps2:              "Debug Change Processor State to EL2"
ARM_dcps3:              "Debug Change Processor State to EL3"
ARM_hlt:                "Halting mode software breakpoint"
ARM_sevl:               "Send Event Locally"

// ARMv8 AArch64 new instructions

ARM_tbz:                "Test and Branch Zero"
ARM_tbnz:               "Test and Branch Non-Zero"
ARM_br:                 "Branch To Register"
ARM_blr:                "Branch and Link Register"
ARM_ldur:               "Load Single Register (unscaled offset)"
ARM_stur:               "Store Single Register (unscaled offset)"
ARM_ldp:                "Load Pair"
ARM_stp:                "Store Pair"
ARM_ldnp:               "Load Non-temporal Pair"
ARM_stnp:               "Store Non-temporal Pair"
ARM_ldtr:               "Load Unprivileged Register"
ARM_sttr:               "Store Unprivileged Register"
ARM_ldxr:               "Load Exclusive Register"
ARM_stxr:               "Store Exclusive Register"
ARM_ldxp:               "Load Exclusive Pair"
ARM_stxp:               "Store Exclusive Pair"
ARM_ldar:               "Load-Acquire Register"
ARM_stlr:               "Store-Release Register"
ARM_ldaxr:              "Load-Acquire Exclusive Register"
ARM_stlxr:              "Store-Release Exclusive Register"
ARM_ldaxp:              "Load-Acquire Exclusive Pair"
ARM_stlxp:              "Store Exclusive Pair"
ARM_prfm:               "Prefetch Memory"
ARM_prfum:              "Prefetch Memory (unscaled offset)"
ARM_movi:               "Move Immediate"
ARM_mvni:               "Move Inverted Immediate"
ARM_movz:               "Move with Zero"
ARM_movn:               "Move with Not"
ARM_movk:               "Move with Keep"
ARM_adrp:               "Address of Page"
ARM_bfm:                "Bitfield Move"
ARM_sbfm:               "Signed Bitfield Move"
ARM_ubfm:               "Unsigned Bitfield Move"
//ARM_bfi:                "Bitfield Insert"
ARM_bfxil:              "Bitfield Extract and Insert Low"
ARM_sbfiz:              "Signed Bitfield Insert in Zeros"
//ARM_sbfx:               "Signed Bitfield Extract"
ARM_ubfiz:              "Unsigned Bitfield Insert in Zeros"
//ARM_ubfx:               "Unsigned Bitfield Extract"
ARM_extr:               "Extract"
ARM_sxtw:               "Signed Extend Word"
ARM_uxtw:               "Unsigned Extend Word"
ARM_eon:                "Bitwise exclusive OR NOT"
ARM_not:                "Bitwise NOT"
ARM_cls:                "Count Leading Sign Bits"
ARM_rev32:              "Reverse Bytes in Words"
ARM_csel:               "Conditional Select"
ARM_csinc:              "Conditional Select Increment"
ARM_csinv:              "Conditional Select Invert"
ARM_csneg:              "Conditional Select Negate"
ARM_cset:               "Conditional Set"
ARM_csetm:              "Conditional Set Mask"
ARM_cinc:               "Conditional Increment"
ARM_cinv:               "Conditional Invert"
ARM_cneg:               "Conditional Negate"
ARM_ngc:                "Negate with Carry"
ARM_ccmn:               "Conditional Compare Negative"
ARM_ccmp:               "Conditional Compare"
ARM_madd:               "Multiply-Add"
ARM_msub:               "Multiply-Subtract"
ARM_mneg:               "Multiply-Negate"
ARM_smaddl:             "Signed Multiply-Add Long"
ARM_smsubl:             "Signed Multiply-Subtract Long"
ARM_smnegl:             "Signed Multiply-Negate Long"
ARM_smulh:              "Signed Multiply High"
ARM_umaddl:             "Unsigned Multiply-Add Long"
ARM_umsubl:             "Unsigned Multiply-Subtract Long"
ARM_umnegl:             "Unsigned Multiply-Negate Long"
ARM_umulh:              "Unsigned Multiply High"

ARM_drps:               "Debug Restore Processor State"
ARM_sys:                "System Maintenance Operation"
ARM_sysl:               "System Maintenance Operation With Result"
ARM_ic:                 "Instruction Cache Maintenance"
ARM_dc:                 "Data Cache Maintenance"
ARM_at:                 "Address Translation"
ARM_tlbi:               "TLB Invalidation"
ARM_hint:               "Hint instruction"
ARM_brk: { op1 ?        // breakpoints
  0xF003: { filetype ?
    f_PE || f_COFF:     "__fastfail(X0)"
    other:              "Monitor debug-mode breakpoint"
    }
  other:                "Monitor debug-mode breakpoint"
  }

// AArch64 Advanced SIMD
ARM_uaba:               "Unsigned Integer Absolute Difference and Accumulate"
ARM_saba:               "Signed Integer Absolute Difference and Accumulate"
ARM_uabal:              "Unsigned Integer Absolute Difference and Accumulate Long"
ARM_uabal2:             "Unsigned Integer Absolute Difference and Accumulate Long (Second Part)"
ARM_sabal:              "Signed Integer Absolute Difference and Accumulate Long"
ARM_sabal2:             "Signed Integer Absolute Difference and Accumulate Long (Second Part)"
ARM_uabd:               "Unsigned Integer Absolute Difference"
ARM_sabd:               "Signed Integer Absolute Difference"
ARM_fabd:               "Floating-point Absolute Difference"
ARM_uabdl:              "Unsigned Integer Absolute Difference Long"
ARM_sabdl:              "Signed Integer Absolute Difference Long"
ARM_uabdl2:             "Unsigned Integer Absolute Difference Long (Second Part)"
ARM_sabdl2:             "Signed Integer Absolute Difference Long (Second Part)"
ARM_abs:                "Integer Absolute Value"
ARM_fabs:               "Floating-point Absolute Value"
ARM_facge:              "Floating-point Absolute Compare Greater Than or Equal"
ARM_facgt:              "Floating-point Absolute Compare Greater Than"
ARM_facle:              "Floating-point Absolute Compare Less Than or Equal"
ARM_faclt:              "Floating-point Absolute Compare Less Than"
ARM_fadd:               "Floating-point Add"
ARM_addhn:              "Integer Vector Add and Narrow High Half"
ARM_addhn2:             "Integer Vector Add and Narrow High Half (second part)"
ARM_uaddl:              "Unsigned Integer Add Long"
ARM_saddl:              "Signed Integer Add Long"
ARM_uaddl2:             "Unsigned Integer Add Long (second part)"
ARM_saddl2:             "Signed Integer Add Long (second part)"
ARM_uaddw:              "Unsigned Integer Add Wide"
ARM_saddw:              "Signed Integer Add Wide"
ARM_uaddw2:             "Unsigned Integer Add Wide (second part)"
ARM_saddw2:             "Signed Integer Add Wide (second part)"
ARM_bif:                "Bitwise Vector Insert if False"
ARM_bit:                "Bitwise Vector Insert if True"
ARM_bsl:                "Bitwise Vector Select"
ARM_cmeq:               "Ingeger Vector Compare Equal"
ARM_fcmeq:              "Floating-point Vector Compare Equal"
ARM_cmhs:               "Unsigned Compare Greater Than or Equal"
ARM_cmge:               "Signed Compare Greater Than or Equal"
ARM_fcmge:              "Floating-point Compare Greater Than or Equal"
ARM_cmhi:               "Unsigned Compare Greater Than"
ARM_cmgt:               "Signed Compare Greater Than"
ARM_fcmgt:              "Floating-point Compare Greater Than"
ARM_cmls:               "Unsigned Compare Less Than or Equal"
ARM_cmle:               "Signed Compare Less Than or Equal"
ARM_fcmle:              "Floating-point Compare Less Than or Equal"
ARM_cmlo:               "Unsigned Compare Less Than"
ARM_cmlt:               "Signed Compare Less Than"
ARM_fcmlt:              "Floating-point Compare Less Than"
ARM_fcmp:               "Floating-point Compare"
ARM_fcmpe:              "Floating-point Signaling Compare"
ARM_fccmp:              "Floating-point Conditional Quiet Compare"
ARM_fccmpe:             "Floating-point Conditional Signaling Compare"
ARM_fcsel:              "Floating-point Conditional Select"
ARM_cnt:                "Vector Count Non-zero Bits"
ARM_fcvt:               "Floating-point convert precision (scalar)"
ARM_fcvtzs:             "Convert Floating-point to Signed Integer (Round to Zero)"
ARM_fcvtas:             "Convert Floating-point to Signed Integer (Round to Nearest, Ties to Away)"
ARM_fcvtns:             "Convert Floating-point to Signed Integer (Round to Nearest, Ties to Even)"
ARM_fcvtps:             "Convert Floating-point to Signed Integer (Round towards +Infinity)"
ARM_fcvtms:             "Convert Floating-point to Signed Integer (Round towards -Infinity)"
ARM_fcvtzu:             "Convert Floating-point to Unsigned Integer (Round to Zero)"
ARM_fcvtau:             "Convert Floating-point to Unsigned Integer (Round to Nearest, Ties to Away)"
ARM_fcvtnu:             "Convert Floating-point to Unsigned Integer (Round to Nearest, Ties to Even)"
ARM_fcvtpu:             "Convert Floating-point to Unsigned Integer (Round towards +Infinity)"
ARM_fcvtmu:             "Convert Floating-point to Unsigned Integer (Round towards -Infinity)"
ARM_ucvtf:              "Convert Unsigned Integer to Floating-point"
ARM_scvtf:              "Convert Signed Integer to Floating-point"
ARM_fcvtn:              "Floating-point Convert Precision, Narrow"
ARM_fcvtn2:             "Floating-point Convert Precision, Narrow (second part)"
ARM_fcvtl:              "Floating-point Convert Precision, Long"
ARM_fcvtl2:             "Floating-point Convert Precision, Long (second part)"
ARM_fcvtxn:             "Floating-point Convert Precision, Narrow (Round to Odd)"
ARM_fcvtxn2:            "Floating-point Convert Precision, Narrow (Round to Odd) (second part)"
ARM_frinta:             "Floating-point Round to Integral (Round to Nearest, Ties to Away)"
ARM_frinti:             "Floating-point Round to Integral (using FPCR rounding mode)"
ARM_frintm:             "Floating-point Round to Integral (Round towards -Infinity)"
ARM_frintn:             "Floating-point Round to Integral (Round to Nearest, Ties to Even)"
ARM_frintp:             "Floating-point Round to Integral (Round towards +Infinity)"
ARM_frintx:             "Floating-point Round to Integral (using FPCR rounding mode, with exactness test)"
ARM_frintz:             "Floating-point Round to Integral (Round towards Zero)"
ARM_fmadd:              "Floating-point scalar fused multiply-add"
ARM_fmsub:              "Floating-point scalar fused multiply-subtract"
ARM_fnmadd:             "Floating-point scalar negated fused multiply-add"
ARM_fnmsub:             "Floating-point scalar negated fused multiply-subtract"
ARM_fdiv:               "Floating-point Divide"
ARM_dup:                "Duplicate Single Element to All Elements"
ARM_ins:                "Insert Single Element in Another Element"
ARM_ext:                "Bitwise Extract"
ARM_uhadd:              "Unsigned Integer Halving Add"
ARM_shadd:              "Signed Integer Halving Add"
ARM_uhsub:              "Unsigned Integer Halving Subtract"
ARM_shsub:              "Signed Integer Halving Subtract"
ARM_ld1:                "Vector Load Single Element"
ARM_ld2:                "Vector Load Two-Element Structures"
ARM_ld3:                "Vector Load Three-Element Structures"
ARM_ld4:                "Vector Load Four-Element Structures"
ARM_ld1r:               "Vector Load Single Element and Replicate"
ARM_ld2r:               "Vector Load Two-Element Structures and Replicate"
ARM_ld3r:               "Vector Load Three-Element Structures and Replicate"
ARM_ld4r:               "Vector Load Four-Element Structures and Replicate"
ARM_umax:               "Unsigned Integer Maximum"
ARM_smax:               "Signed Integer Maximum"
ARM_fmax:               "Floating-point Maximum"
ARM_fmaxnm:             "Floating-point maxNum()"
ARM_umin:               "Unsigned Integer Minimum"
ARM_smin:               "Signed Integer Minimum"
ARM_fmin:               "Floating-point Minimum"
ARM_fminnm:              "Floating-point minNum()"
ARM_fmla:               "Fused Multiply-Add"
ARM_umlal2:             "Unsigned Integer Multiply-Add Long (second part)"
ARM_smlal2:             "Signed Integer Multiply-Add Long (second part)"
ARM_fmls:               "Fused Multiply-Subtract"
ARM_umlsl:              "Unsigned Integer Multiply-Subtract Long"
ARM_smlsl:              "Signed Integer Multiply-Subtract Long"
ARM_umlsl2:             "Unsigned Integer Multiply-Subtract Long (second part)"
ARM_smlsl2:             "Signed Integer Multiply-Subtract Long (second part)"
ARM_umov:               "Unsigned Integer Move"
ARM_smov:               "Signed Integer Move"
ARM_fmov:               "Floating-point Move"
ARM_uxtl:               "Unsigned Integer Vector Lengthen"
ARM_sxtl:               "Signed Integer Vector Lengthen"
ARM_uxtl2:              "Unsigned Integer Vector Lengthen (second part)"
ARM_sxtl2:              "Signed Integer Vector Lengthen (second part)"
ARM_xtn:                "Integer Vector Narrow"
ARM_xtn2:               "Integer Vector Narrow (second part)"
ARM_fmul:               "Floating-point Vector Multiply"
ARM_pmul:               "Polynomial Vector Multiply"
ARM_fmulx:              "Floating-point Multiply Extended"
ARM_fnmul:              "Floating-point Multiply-Negate"
ARM_umull2:             "Unsigned Integer Vector Multiply Long (second part)"
ARM_smull2:             "Signed Integer Vector Multiply Long (second part)"
ARM_pmull:              "Polynomial Vector Multiply Long"
ARM_pmull2:             "Polynomial Vector Multiply Long (second part)"
ARM_fneg:               "Floating-point Negate"
ARM_uadalp:             "Unsigned Integer Vector Add and Accumulate Long Pair"
ARM_sadalp:             "Signed Integer Vector Add and Accumulate Long Pair"
ARM_addp:               "Integer Vector Add Pair"
ARM_faddp:              "Floating-point Vector Add Pair"
ARM_uaddlp:             "Unsigned Integer Vector Add Long Pair"
ARM_saddlp:             "Signed Integer Vector Add Long Pair"
ARM_umaxp:              "Unsigned Integer Maximum Pair"
ARM_smaxp:              "Signed Integer Maximum Pair"
ARM_fmaxp:              "Floating-point Maximum Pair"
ARM_fmaxnmp:            "Floating-point maxNum Pair"
ARM_uminp:              "Unsigned Integer Minimum Pair"
ARM_sminp:              "Signed Integer Minimum Pair"
ARM_fminp:              "Floating-point Minimum Pair"
ARM_fminnmp:            "Floating-point minNum Pair"
ARM_sqabs:              "Signed Integer Saturating Absolute"
ARM_uqadd:              "Unsigned Integer Saturating Add"
ARM_sqadd:              "Signed Integer Saturating Add"
ARM_suqadd:             "Signed Integer Saturating Accumulate of Unsigned Values"
ARM_usqadd:             "Unsigned Integer Saturating Accumulate of Signed Values"
ARM_sqdmlal:            "Signed Integer Saturating Doubling Multiply Add Long"
ARM_sqdmlal2:           "Signed Integer Saturating Doubling Multiply Add Long (second part)"
ARM_sqdmlsl:            "Signed Integer Saturating Doubling Multiply Subtract Long"
ARM_sqdmlsl2:           "Signed Integer Saturating Doubling Multiply Subtract Long (second part)"
ARM_sqdmulh:            "Signed Integer Saturating Doubling Multiply Returning High Half"
ARM_sqdmull:            "Signed Integer Saturating Doubling Multiply Long"
ARM_sqdmull2:           "Signed Integer Saturating Doubling Multiply Long (second part)"
ARM_uqxtn:              "Unsigned Integer Saturating Vector Narrow"
ARM_uqxtn2:             "Unsigned Integer Saturating Vector Narrow (second part)"
ARM_sqxtn:              "Signed Integer Saturating Vector Narrow"
ARM_sqxtn2:             "Signed Integer Saturating Vector Narrow (second part)"
ARM_sqxtun:             "Signed Integer Saturating Vector and Unsigned Narrow"
ARM_sqxtun2:            "Signed Integer Saturating Vector and Unsigned Narrow (second part)"
ARM_sqneg:              "Signed Integer Saturating Negate"
ARM_sqrdmulh:           "Signed Integer Saturating Rounding Doubling Multiply Returning High Half"
ARM_uqrshl:             "Unsigned Integer Saturating Rounding Shift Left"
ARM_sqrshl:             "Signed Integer Saturating Rounding Shift Left"
ARM_uqrshrn:            "Unsigned Integer Saturating Rounding Shift Right, Narrow"
ARM_uqrshrn2:           "Unsigned Integer Saturating Rounding Shift Right, Narrow (second part)"
ARM_sqrshrn:            "Signed Integer Saturating Rounding Shift Right, Narrow"
ARM_sqrshrn2:           "Signed Integer Saturating Rounding Shift Right, Narrow (second part)"
ARM_sqrshrun:           "Signed Integer Saturating Rounding Shift Right, Narrow, Unsigned result"
ARM_sqrshrun2:          "Signed Integer Saturating Rounding Shift Right, Narrow, Unsigned result (second part)"
ARM_uqshl:              "Unsigned Integer Saturating Shift Left"
ARM_sqshl:              "Signed Integer Saturating Shift Left"
ARM_sqshlu:             "Signed Integer Saturating Shift Left, Unsigned result"
ARM_uqshrn:             "Unsigned Integer Saturating Shift Right, Narrow"
ARM_uqshrn2:            "Unsigned Integer Saturating Shift Right, Narrow (second part)"
ARM_sqshrn:             "Signed Integer Saturating Shift Right, Narrow"
ARM_sqshrn2:            "Signed Integer Saturating Shift Right, Narrow (second part)"
ARM_sqshrun:            "Signed Integer Saturating Shift Right, Narrow, Unsigned result"
ARM_sqshrun2:           "Signed Integer Saturating Shift Right, Narrow, Unsigned result (second part)"
ARM_uqsub:              "Unsigned Integer Saturating Subtract"
ARM_sqsub:              "Signed Integer Saturating Subtract"
ARM_raddhn:             "Integer Rounding Add and Narrow, returning High Half"
ARM_raddhn2:            "Integer Rounding Add and Narrow, returning High Half (second part)"
ARM_urecpe:             "Unsigned Integer Reciprocal Estimate"
ARM_frecpe:             "Floating-point Reciprocal Estimate"
ARM_frecps:             "Floating-point Reciprocal Step"
ARM_frecpx:             "Floating-point Reciprocal Exponent"
ARM_rev64:              "Reverse doublewords"
ARM_urhadd:             "Unsigned Integer Rounding Halving Add"
ARM_srhadd:             "Signed Integer Rounding Halving Add"
ARM_urshl:              "Unsigned Integer Rounding Shift Left"
ARM_srshl:              "Signed Integer Rounding Shift Left"
ARM_urshr:              "Unsigned Integer Rounding Shift Right"
ARM_srshr:              "Signed Integer Rounding Shift Right"
ARM_rshrn:              "Integer Rounding Shift Right and Narrow"
ARM_rshrn2:             "Integer Rounding Shift Right and Narrow (second part)"
ARM_ursqrte:            "Unsigned Integer Reciprocal Square Root Estimate"
ARM_frsqrte:            "Floating-point Reciprocal Square Root Estimate"
ARM_frsqrts:            "Floating-point Reciprocal Square Root Step"
ARM_ursra:              "Unsigned Integer Rounding Shift Right and Accumulate"
ARM_srsra:              "Signed Integer Rounding Shift Right and Accumulate"
ARM_rsubhn:             "Integer Subtract and Narrow, returning High Half"
ARM_rsubhn2:            "Integer Subtract and Narrow, returning High Half (second part)"
ARM_ushl:               "Unsigned Integer Shift Left"
ARM_sshl:               "Signed Integer Shift Left"
ARM_ushll:              "Unsigned Integer Shift Left Long"
ARM_ushll2:             "Unsigned Integer Shift Left Long (second part)"
ARM_sshll:              "Signed Integer Shift Left Long"
ARM_sshll2:             "Signed Integer Shift Left Long (second part)"
ARM_ushr:               "Unsigned Integer Shift Right"
ARM_sshr:               "Signed Integer Shift Right"
ARM_shrn:               "Integer Shift Right Narrow"
ARM_shrn2:              "Integer Shift Right Narrow (second part)"
ARM_shl:                "Shift Left"
ARM_shll:               "Shift Left Long"
ARM_shll2:              "Shift Left Long (second part)"
ARM_sli:                "Integer Vector Shift Left and Insert"
ARM_fsqrt:              "Floating-point Square Root"
ARM_usra:               "Unsigned Integer Shift Right and Accumulate"
ARM_ssra:               "Signed Integer Shift Right and Accumulate"
ARM_sri:                "Integer Shift Right and Insert"
ARM_st1:                "Vector Store Single Element"
ARM_st2:                "Vector Store Two-Element Structures"
ARM_st3:                "Vector Store Three-Element Structures"
ARM_st4:                "Vector Store Four-Element Structures"
ARM_fsub:               "Floating-point Subtract"
ARM_subhn:              "Integer Subtract and Narrow, returning High Half"
ARM_subhn2:             "Integer Subtract and Narrow, returning High Half (second part)"
ARM_usubl:              "Unsigned Integer Subtract Long"
ARM_usubl2:             "Unsigned Integer Subtract Long (second part)"
ARM_ssubl:              "Signed Integer Subtract Long"
ARM_ssubl2:             "Signed Integer Subtract Long (second part)"
ARM_usubw:              "Unsigned Integer Subtract Wide"
ARM_usubw2:             "Unsigned Integer Subtract Wide (second part)"
ARM_ssubw:              "Signed Integer Subtract Wide"
ARM_ssubw2:             "Signed Integer Subtract Wide (second part)"
ARM_tbl:                "Vector Table Lookup"
ARM_tbx:                "Vector Table Extension"
ARM_trn1:               "Vector Element Transpose (primary)"
ARM_trn2:               "Vector Element Transpose (secondary)"
ARM_cmtst:              "Integer Compare Mask Bitwise Test"
ARM_uzp1:               "Vector Element Unzip (primary)"
ARM_uzp2:               "Vector Element Unzip (secondary)"
ARM_zip1:               "Vector Element Zip (primary)"
ARM_zip2:               "Vector Element Zip (secondary)"
ARM_addv:               "Integer Sum Elements in Vector"
ARM_uaddlv:             "Unsigned Integer Sum Elements in Vector Long"
ARM_saddlv:             "Signed Integer Sum Elements in Vector Long"
ARM_umaxv:              "Unsigned Integer Max Element in Vector"
ARM_smaxv:              "Signed Integer Max Element in Vector"
ARM_fmaxv:              "Floating-point Max Element in Vector"
ARM_fmaxnmv:            "Floating-point maxNum Element in Vector"
ARM_uminv:              "Unsigned Integer Min Element in Vector"
ARM_sminv:              "Signed Integer Min Element in Vector"
ARM_fminv:              "Floating-point Min Element in Vector"
ARM_fminnmv:            "Floating-point minNum Element in Vector"

//ARM_swp,              "Swap value with memory, No memory ordering"
ARM_swpl:                "Swap value with memory, Release"
ARM_swpa:                "Swap value with memory, Acquire"
ARM_swpal:               "Swap value with memory, Acquire and release"

ARM_ldapr:              "Load-Acquire RCpc Register"

ARM_ldadd:             "Atomic add on value in memory (return initial value), No memory ordering"
ARM_ldaddl:            "Atomic add on value in memory (return initial value), Release"
ARM_ldadda:            "Atomic add on value in memory (return initial value), Acquire"
ARM_ldaddal:           "Atomic add on value in memory (return initial value), Acquire and release"
ARM_stadd:             "Atomic add on value in memory (no return), No memory ordering"
ARM_staddl:            "Atomic add on value in memory (no return), Release"

ARM_ldclr:             "Atomic bit clear on value in memory (return initial value), No memory ordering"
ARM_ldclrl:            "Atomic bit clear on value in memory (return initial value), Release"
ARM_ldclra:            "Atomic bit clear on value in memory (return initial value), Acquire"
ARM_ldclral:           "Atomic bit clear on value in memory (return initial value), Acquire and release"
ARM_stclr:             "Atomic bit clear on value in memory (no return), No memory ordering"
ARM_stclrl:            "Atomic bit clear on value in memory (no return), Release"

ARM_ldeor:             "Atomic exclusive OR on value in memory (return initial value), No memory ordering"
ARM_ldeorl:            "Atomic exclusive OR on value in memory (return initial value), Release"
ARM_ldeora:            "Atomic exclusive OR on value in memory (return initial value), Acquire"
ARM_ldeoral:           "Atomic exclusive OR on value in memory (return initial value), Acquire and release"
ARM_steor:             "Atomic exclusive OR on value in memory (no return), No memory ordering"
ARM_steorl:            "Atomic exclusive OR on value in memory (no return), Release"

ARM_ldset:             "Atomic bit set on value in memory (return initial value), No memory ordering"
ARM_ldsetl:            "Atomic bit set on value in memory (return initial value), Release"
ARM_ldseta:            "Atomic bit set on value in memory (return initial value), Acquire"
ARM_ldsetal:           "Atomic bit set on value in memory (return initial value), Acquire and release"
ARM_stset:             "Atomic bit set on value in memory (no return), No memory ordering"
ARM_stsetl:            "Atomic bit set on value in memory (no return), Release"

ARM_ldsmax:            "Atomic signed maximum  on value in memory (return initial value), No memory ordering"
ARM_ldsmaxl:           "Atomic signed maximum  on value in memory (return initial value), Release"
ARM_ldsmaxa:           "Atomic signed maximum  on value in memory (return initial value), Acquire"
ARM_ldsmaxal:          "Atomic signed maximum  on value in memory (return initial value), Acquire and release"
ARM_stsmax:            "Atomic signed maximum  on value in memory (no return), No memory ordering"
ARM_stsmaxl:            "Atomic signed maximum  on value in memory (no return), Release"


ARM_ldsmin:            "Atomic signed minimum  on value in memory (return initial value), No memory ordering"
ARM_ldsminl:           "Atomic signed minimum  on value in memory (return initial value), Release"
ARM_ldsmina:           "Atomic signed minimum  on value in memory (return initial value), Acquire"
ARM_ldsminal:          "Atomic signed minimum  on value in memory (return initial value), Acquire and release"
ARM_stsmin:            "Atomic signed minimum  on value in memory (no return), No memory ordering"
ARM_stsminl:            "Atomic signed minimum  on value in memory (no return), Release"

ARM_ldumax:            "Atomic unsigned maximum  on value in memory (return initial value), No memory ordering"
ARM_ldumaxl:           "Atomic unsigned maximum  on value in memory (return initial value), Release"
ARM_ldumaxa:           "Atomic unsigned maximum  on value in memory (return initial value), Acquire"
ARM_ldumaxal:          "Atomic unsigned maximum  on value in memory (return initial value), Acquire and release"
ARM_stumax:            "Atomic unsigned maximum  on value in memory (no return), No memory ordering"
ARM_stumaxl:            "Atomic unsigned maximum  on value in memory (no return), Release"


ARM_ldumin:            "Atomic unsigned minimum  on value in memory (return initial value), No memory ordering"
ARM_lduminl:           "Atomic unsigned minimum  on value in memory (return initial value), Release"
ARM_ldumina:           "Atomic unsigned minimum  on value in memory (return initial value), Acquire"
ARM_lduminal:          "Atomic unsigned minimum  on value in memory (return initial value), Acquire and release"
ARM_stumin:            "Atomic unsigned minimum  on value in memory (no return), No memory ordering"
ARM_stuminl:            "Atomic unsigned minimum  on value in memory (no return), Release"

//Compare and Swap (ARMv8.1)

ARM_cas:            "Compare and Swap , No memory ordering"
ARM_casl:           "Compare and Swap, Release"
ARM_casa:           "Compare and Swap, Acquire"
ARM_casal:          "Compare and Swap, Acquire and release"

ARM_casp:            "Compare and Swap Pair, No memory ordering"
ARM_caspl:           "Compare and Swap Pair, Release"
ARM_caspa:           "Compare and Swap Pair, Acquire"
ARM_caspal:          "Compare and Swap Pair, Acquire and release"

ARM_ldlar:           "Load LOAcquire Register"
ARM_stllr:           "Store LORelease Register"

ARM_sqrdmlah:        "Signed Saturating Rounding Doubling Multiply Accumulate"
ARM_sqrdmlsh:        "Signed Saturating Rounding Doubling Multiply Subtract"

ARM_pac:             "Pointer Authentication Code for address"
ARM_aut:             "Authenticate address"
ARM_xpac:            "Strip Pointer Authentication Code"

ARM_tt:              "Test Target (query the Security state and access permissions of a memory location)"
ARM_tta:             "Test Target Alternate Domain (query the Security state and access permissions of a memory location for a Non-secure access)"
ARM_sg:              "Secure Gateway (marks valid branch target for branches from Non-secure code)"
ARM_vlldm:           "Floating-point Lazy Load Multiple"
ARM_vlstm:           "Floating-point Lazy Store Multiple"

ARM_pldw:            "Preload data for Write"

ARM_vqrdmlah:        "Vector Saturating Rounding Doubling Multiply Accumulate Returning High Half."
ARM_vqrdmlsh:        "Vector Saturating Rounding Doubling Multiply Subtract Returning High Half"

ARM_vmovx:           "Vector Move extraction"
ARM_vins:            "Vector move Insertion."
ARM_vjcvt:           "Javascript Convert to signed fixed-point, rounding toward Zero"
ARM_fjcvtzs:         "Javascript Convert to signed fixed-point, rounding toward Zero"
ARM_ldapur:          "Load-Acquire RCpc Register (unscaled offset)"
ARM_stlur:           "Store-Release Register (unscaled offset)"

ARM_cfinv:           "Invert Carry Flag"
ARM_rmif:            "Rotate value and mask into flags"
ARM_setf8:           "Set flags from value (8-bit)"
ARM_setf16:          "Set flags from value (16-bit)"
ARM_xaflag:          "Convert floating-point condition flags to ARM format"
ARM_axflag:          "Convert floating-point condition flags from ARM to external format."

ARM_addg:            "Add with Tag"
ARM_subg:            "Subtract with Tag"
ARM_subp:            "Subtract Pointer"
ARM_cmpp:            "Compare with Tag"
ARM_irg:             "Insert Random Tag"
ARM_gmi:             "Tag Mask Insert"
ARM_stg:             "Store Allocation Tag"
ARM_stzg:            "Store Allocation Tag, Zeroing"
ARM_stzgm:           "Store Tag and Zero Multiple"
ARM_st2g:            "Store Allocation Tags"
ARM_stz2g:           "Store Allocation Tags, Zeroing"
ARM_stgm:            "Store Tag Multiple"
ARM_stgp:            "Store Allocation Tag and Pair of registers"
ARM_ldg:             "Load Allocation Tag"
ARM_ldgm:            "Load Tag Multiple"
ARM_bti:             "Branch Target Identification"
ARM_sb:              "Speculation Barrier "
ARM_ssbb:            "Speculative Store Bypass Barrier"
ARM_pssbb:           "Physical Speculative Store Bypass Barrier"
ARM_frint32x:        "Floating-point Round to 32-bit Integer, using current rounding mode"
ARM_frint32z:        "Floating-point Round to 32-bit Integer toward Zero"
ARM_frint64x:        "Floating-point Round to 32-bit Integer, using current rounding mode"
ARM_frint64z:        "Floating-point Round to 32-bit Integer toward Zero"

// Apple  custom instructions

ARM_genter:           "Enter guarded execution mode"
ARM_gexit:            "Exit guarded execution mode"

// ARMv8.2-SHA3 (AArch64)
ARM_bcax:             "Bit Clear and exclusive-OR"
ARM_eor3:             "Three-way Exclusive-OR"
ARM_rax1:             "Rotate and Exclusive-OR"
ARM_xar:              "Exclusive-OR and Rotate"

// ARMv8.2-SHA512 (AArch64)
ARM_sha512h:          "SHA512 Hash update part 1"
ARM_sha512h2:         "SHA512 Hash update part 2"
ARM_sha512su0:        "SHA512 Schedule Update 0"
ARM_sha512su1:        "SHA512 Schedule Update 1"

// ARMv8.2-SM3 (AArch64)
ARM_sm3partw1:        "SM3PARTW1"
ARM_sm3partw2:        "SM3PARTW2"
ARM_sm3ss1:           "SM3SS1"
ARM_sm3tt1a:          "SM3TT1A"
ARM_sm3tt1b:          "SM3TT1B"
ARM_sm3tt2a:          "SM3TT2A"
ARM_sm3tt2b:          "SM3TT2B"

// ARMv8.2-SM4 (AArch64)
ARM_sm4e:             "SM4 Encode"
ARM_sm4ekey:          "SM4 Key"

// ARMv8.6-I8MM (AArch64)
ARM_sudot:            "Dot product index form with signed and unsigned integers"
ARM_ummla:            "Unsigned 8-bit integer matrix multiply-accumulate"
ARM_usdot:            "Dot Product index form with unsigned and signed integers"
ARM_usmmla:           "Unsigned and signed 8-bit integer matrix multiply-accumulate"

// ARMv8.6-DotProd (AArch64)
ARM_sdot:             "Dot Product signed arithmetic"
ARM_udot:             "Dot Product unsigned arithmetic"

// ARMv8.2-FHM (AArch64)
ARM_fmlal:            "Floating-point fused Multiply-Add Long to accumulator"
ARM_fmlal2:           "Floating-point fused Multiply-Add Long to accumulator"
ARM_fmlsl:            "Floating-point fused Multiply-Subtract Long from accumulator"
ARM_fmlsl2:           "Floating-point fused Multiply-Subtract Long from accumulator"

// ARMv8.6-BF16 (AArch64)
ARM_bfmmla:           "BFloat16 floating-point matrix multiply-accumulate into 2x2 matrix"
ARM_bfmlalb:          "BFloat16 floating-point multiply-add long to single-precision (bottom)"
ARM_bfmlalt:          "BFloat16 floating-point multiply-add long to single-precision (top)"
ARM_bfdot:            "BFloat16 floating-point dot product"
ARM_bfcvtn:           "Floating-point convert from single-precision to BFloat16 format (vector)"
ARM_bfcvtn2:          "Floating-point convert from single-precision to BFloat16 format (vector)"
ARM_bfcvt:            "Floating-point convert from single-precision to BFloat16 format (scalar)"