inst_patterns.go

// Code generated by gen/inst/inst.go; DO NOT EDIT.

package arm

// The Patterns table contains matching info for all instruction encodings.
// Each instruction's list of encodings is prefixed with the encoding count,
// followed by a length-prefixed list of matching operators and commands offset
// for each encoding; the commands offset is a 16-bit index into the Commands table.
// Matching operators apply to unflattened Arg types.
var Patterns = [...]byte{
	0,
	5,
	// abs Dd, Dn
	2, MatD, MatD, 0x0, 0x0,
	// abs Vd.16B, Vn.16B
	// abs Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x0, 0x7,
	// abs Vd.8H, Vn.8H
	// abs Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x0, 0xf,
	// abs Vd.4S, Vn.4S
	// abs Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x0, 0x17,
	// abs Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x0, 0x1f,

	2,
	// adc Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x0, 0x27,
	// adc Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x0, 0x2f,

	2,
	// adcs Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x0, 0x37,
	// adcs Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x0, 0x3f,

	12,
	// add Wd, Wn, Wm {, LSL|LSR|ASR #imm }  ·········································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymShifts, 0x0, 0x47,
	// add Xd, Xn, Xm {, LSL|LSR|ASR #imm }  ·········································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymShifts, 0x0, 0x53,
	// add Wd|WSP, Wn|WSP, Wm {, LSL|UXT[BHWX]|SXT[BHWX] #imm }  ·····················  (0 <= imm <= 4)
	5, MatWSP, MatWSP, MatW, MatEnd, MatMod, SymExtends, 0x0, 0x5f,
	// add Xd|SP, Xn|SP, Wm {, UXT[BHW]|SXT[BHW] #imm }  ·····························  (0 <= imm <= 4)
	5, MatXSP, MatXSP, MatW, MatEnd, MatMod, SymExtendsW, 0x0, 0x6c,
	// add Xd|SP, Xn|SP, Xm {, LSL|UXTX|SXTX #imm }  ·································  (0 <= imm <= 4)
	5, MatXSP, MatXSP, MatX, MatEnd, MatMod, SymExtendsX, 0x0, 0x79,
	// add Wd|WSP, Wn|WSP, #imm1 {, LSL #imm2 }  ·················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatWSP, MatWSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x0, 0x86,
	// add Xd|SP, Xn|SP, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatXSP, MatXSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x0, 0x93,
	// add Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x0, 0xa0,
	// add Vd.16B, Vn.16B, Vm.16B
	// add Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x0, 0xa8,
	// add Vd.8H, Vn.8H, Vm.8H
	// add Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x0, 0xb1,
	// add Vd.4S, Vn.4S, Vm.4S
	// add Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x0, 0xba,
	// add Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x0, 0xc3,

	3,
	// addhn Vd.8B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x0, 0xcc,
	// addhn Vd.4H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x0, 0xd4,
	// addhn Vd.2S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x0, 0xdc,

	3,
	// addhn2 Vd.16B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x0, 0xe4,
	// addhn2 Vd.8H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x0, 0xec,
	// addhn2 Vd.4S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x0, 0xf4,

	5,
	// addp Dd, Vn.2D
	2, MatD, MatVStatic, byte(QWORD), 2, 0x0, 0xfc,
	// addp Vd.16B, Vn.16B, Vm.16B
	// addp Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x1, 0x3,
	// addp Vd.8H, Vn.8H, Vm.8H
	// addp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x1, 0xc,
	// addp Vd.4S, Vn.4S, Vm.4S
	// addp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x1, 0x15,
	// addp Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1, 0x1e,

	7,
	// adds Wd, Wn, Wm {, LSL|LSR|ASR #imm }  ········································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymShifts, 0x1, 0x27,
	// adds Xd, Xn, Xm {, LSL|LSR|ASR #imm }  ········································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymShifts, 0x1, 0x33,
	// adds Wd, Wn|WSP, Wm {, LSL|UXT[BHWX]|SXT[BHWX] #imm }  ························  (0 <= imm <= 4)
	5, MatW, MatWSP, MatW, MatEnd, MatMod, SymExtends, 0x1, 0x3f,
	// adds Xd, Xn|SP, Wm {, UXT[BHW]|SXT[BHW] #imm }  ·······························  (0 <= imm <= 4)
	5, MatX, MatXSP, MatW, MatEnd, MatMod, SymExtendsW, 0x1, 0x4c,
	// adds Xd, Xn|SP, Xm {, LSL|UXTX|SXTX #imm }  ···································  (0 <= imm <= 4)
	5, MatX, MatXSP, MatX, MatEnd, MatMod, SymExtendsX, 0x1, 0x59,
	// adds Wd, Wn|WSP, #imm1 {, LSL #imm2 }  ····················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatW, MatWSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x1, 0x66,
	// adds Xd, Xn|SP, #imm1 {, LSL #imm2 }  ·····················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatX, MatXSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x1, 0x73,

	3,
	// addv Bd, Vn.16B
	// addv Bd, Vn.8B
	2, MatB, MatV, byte(BYTE), 0x1, 0x80,
	// addv Hd, Vn.8H
	// addv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x1, 0x88,
	// addv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x1, 0x90,

	1,
	// adr Xd, <offset>  ···············································  (offset is 21-bit (+/- 1 MB))
	2, MatX, MatOffset, 0x1, 0x98,

	1,
	// adrp Xd, <offset>  ········································  (offset >> 12 is 21-bit (+/- 4 GB))
	2, MatX, MatOffset, 0x1, 0xa0,

	1,
	// aesd Vd.16B, Vn.16B
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x1, 0xa8,

	1,
	// aese Vd.16B, Vn.16B
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x1, 0xaf,

	1,
	// aesimc Vd.16B, Vn.16B
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x1, 0xb6,

	1,
	// aesmc Vd.16B, Vn.16B
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x1, 0xbd,

	5,
	// and Vd.16B, Vn.16B, Vm.16B
	// and Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x1, 0xc4,
	// and Wd|WSP, Wn, #imm  ·················································  (imm is 32-bit logical)
	3, MatWSP, MatW, MatImm, 0x1, 0xcd,
	// and Xd|SP, Xn, #imm  ··················································  (imm is 64-bit logical)
	3, MatXSP, MatX, MatImm, 0x1, 0xd7,
	// and Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0x1, 0xe1,
	// and Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0x1, 0xed,

	4,
	// ands Wd, Wn, #imm  ····················································  (imm is 32-bit logical)
	3, MatW, MatW, MatImm, 0x1, 0xf9,
	// ands Xd, Xn, #imm  ····················································  (imm is 64-bit logical)
	3, MatX, MatX, MatImm, 0x2, 0x3,
	// ands Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0x2, 0xd,
	// ands Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0x2, 0x19,

	4,
	// asr Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2, 0x25,
	// asr Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2, 0x2d,
	// asr Wd, Wn, #imm  ·····························································  (0 <= imm < 32)
	3, MatW, MatW, MatImm, 0x2, 0x35,
	// asr Xd, Xn, #imm  ·····························································  (0 <= imm < 64)
	3, MatX, MatX, MatImm, 0x2, 0x3f,

	2,
	// asrv Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2, 0x49,
	// asrv Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2, 0x51,

	1,
	// at <symbol>, Xn
	2, MatSymbol, MatX, 0x2, 0x59,

	1,
	// autda Xd, Xn|SP
	2, MatX, MatXSP, 0x2, 0x62,

	1,
	// autdb Xd, Xn|SP
	2, MatX, MatXSP, 0x2, 0x69,

	1,
	// autdza Xd
	1, MatX, 0x2, 0x70,

	1,
	// autdzb Xd
	1, MatX, 0x2, 0x76,

	1,
	// autia Xd, Xn|SP
	2, MatX, MatXSP, 0x2, 0x7c,

	1,
	// autia1716
	0, 0x2, 0x83,

	1,
	// autiasp
	0, 0x2, 0x88,

	1,
	// autiaz
	0, 0x2, 0x8d,

	1,
	// autib Xd, Xn|SP
	2, MatX, MatXSP, 0x2, 0x92,

	1,
	// autib1716
	0, 0x2, 0x99,

	1,
	// autibsp
	0, 0x2, 0x9e,

	1,
	// autibz
	0, 0x2, 0xa3,

	1,
	// autiza Xd
	1, MatX, 0x2, 0xa8,

	1,
	// autizb Xd
	1, MatX, 0x2, 0xae,

	2,
	// b <cond>, <offset>  ········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatCond, MatOffset, 0x2, 0xb4,
	// b <offset>  ··············································  (offset >> 2 is 26-bit (+/- 128 MB))
	1, MatOffset, 0x2, 0xbd,

	1,
	// bcax Vd.16B, Vn.16B, Vm.16B, Va.16B
	4, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x2, 0xc4,

	2,
	// bfc Wd, #imm1, #imm2  ·····················  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	3, MatW, MatImm, MatImm, 0x2, 0xcd,
	// bfc Xd, #imm1, #imm2  ·····················  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	3, MatX, MatImm, MatImm, 0x2, 0xdc,

	2,
	// bfi Wd, Wn, #imm1, #imm2  ·················  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	4, MatW, MatW, MatImm, MatImm, 0x2, 0xeb,
	// bfi Xd, Xn, #imm1, #imm2  ·················  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x2, 0xfb,

	2,
	// bfm Wd, Wn, #imm1, #imm2  ····································  (0 <= imm1 < 32, 0 <= imm2 < 32)
	4, MatW, MatW, MatImm, MatImm, 0x3, 0xb,
	// bfm Xd, Xn, #imm1, #imm2  ··················  (0 <= imm1 < 64, 0 < imm2 < 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x3, 0x18,

	2,
	// bfxil Wd, Wn, #imm1, #imm2  ···············  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	4, MatW, MatW, MatImm, MatImm, 0x3, 0x27,
	// bfxil Xd, Xn, #imm1, #imm2  ···············  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x3, 0x36,

	5,
	// bic Vd.8H, #imm1 {, LSL #imm2 }  ····························  (0 <= imm1 < 256, imm2 in [0, 8])
	// bic Vd.4H, #imm1 {, LSL #imm2 }  ····························  (0 <= imm1 < 256, imm2 in [0, 8])
	4, MatV, byte(WORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x3, 0x45,
	// bic Vd.4S, #imm1 {, LSL #imm2 }  ····················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	// bic Vd.2S, #imm1 {, LSL #imm2 }  ····················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	4, MatV, byte(DWORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x3, 0x5a,
	// bic Vd.16B, Vn.16B, Vm.16B
	// bic Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3, 0x6f,
	// bic Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0x3, 0x78,
	// bic Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0x3, 0x84,

	2,
	// bics Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0x3, 0x90,
	// bics Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0x3, 0x9c,

	1,
	// bif Vd.16B, Vn.16B, Vm.16B
	// bif Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3, 0xa8,

	1,
	// bit Vd.16B, Vn.16B, Vm.16B
	// bit Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3, 0xb1,

	1,
	// bl <offset>  ·············································  (offset >> 2 is 26-bit (+/- 128 MB))
	1, MatOffset, 0x3, 0xba,

	1,
	// blr Xd
	1, MatX, 0x3, 0xc1,

	1,
	// blraa Xd, Xn|SP
	2, MatX, MatXSP, 0x3, 0xc7,

	1,
	// blraaz Xd
	1, MatX, 0x3, 0xce,

	1,
	// blrab Xd, Xn|SP
	2, MatX, MatXSP, 0x3, 0xd4,

	1,
	// blrabz Xd
	1, MatX, 0x3, 0xdb,

	1,
	// br Xd
	1, MatX, 0x3, 0xe1,

	1,
	// braa Xd, Xn|SP
	2, MatX, MatXSP, 0x3, 0xe7,

	1,
	// braaz Xd
	1, MatX, 0x3, 0xee,

	1,
	// brab Xd, Xn|SP
	2, MatX, MatXSP, 0x3, 0xf4,

	1,
	// brabz Xd
	1, MatX, 0x3, 0xfb,

	1,
	// brk #imm  ··································································  (0 <= imm < 65536)
	1, MatImm, 0x4, 0x1,

	1,
	// bsl Vd.16B, Vn.16B, Vm.16B
	// bsl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x4, 0x9,

	2,
	// cas Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x12,
	// cas Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4, 0x1a,

	2,
	// casa Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x22,
	// casa Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4, 0x2a,

	1,
	// casab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x32,

	1,
	// casah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x3a,

	2,
	// casal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x42,
	// casal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4, 0x4a,

	1,
	// casalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x52,

	1,
	// casalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x5a,

	1,
	// casb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x62,

	1,
	// cash Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x6a,

	2,
	// casl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x72,
	// casl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4, 0x7a,

	1,
	// caslb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x82,

	1,
	// caslh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4, 0x8a,

	2,
	// casp Wn, Wm, Wa, Wb, [Xd|SP]  ··················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatW, MatW, MatW, MatW, MatRefBase, 0x4, 0x92,
	// casp Xn, Xm, Xa, Xb, [Xd|SP]  ··················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatX, MatX, MatX, MatX, MatRefBase, 0x4, 0x9e,

	2,
	// caspa Wn, Wm, Wa, Wb, [Xd|SP]  ·················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatW, MatW, MatW, MatW, MatRefBase, 0x4, 0xaa,
	// caspa Xn, Xm, Xa, Xb, [Xd|SP]  ·················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatX, MatX, MatX, MatX, MatRefBase, 0x4, 0xb6,

	2,
	// caspal Wn, Wm, Wa, Wb, [Xd|SP]  ················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatW, MatW, MatW, MatW, MatRefBase, 0x4, 0xc2,
	// caspal Xn, Xm, Xa, Xb, [Xd|SP]  ················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatX, MatX, MatX, MatX, MatRefBase, 0x4, 0xce,

	2,
	// caspl Wn, Wm, Wa, Wb, [Xd|SP]  ·················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatW, MatW, MatW, MatW, MatRefBase, 0x4, 0xda,
	// caspl Xn, Xm, Xa, Xb, [Xd|SP]  ·················  (n is even, m == n + 1, a is even, b == a + 1)
	5, MatX, MatX, MatX, MatX, MatRefBase, 0x4, 0xe6,

	2,
	// cbnz Wd, <offset>  ·········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatW, MatOffset, 0x4, 0xf2,
	// cbnz Xd, <offset>  ·········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatX, MatOffset, 0x4, 0xfa,

	2,
	// cbz Wd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatW, MatOffset, 0x5, 0x2,
	// cbz Xd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatX, MatOffset, 0x5, 0xa,

	4,
	// ccmn Wd, #imm1, #imm2, <cond>  ·······························  (0 <= imm1 < 32, 0 <= imm2 < 16)
	4, MatW, MatImm, MatImm, MatCond, 0x5, 0x12,
	// ccmn Xd, #imm1, #imm2, <cond>  ·······························  (0 <= imm1 < 32, 0 <= imm2 < 16)
	4, MatX, MatImm, MatImm, MatCond, 0x5, 0x20,
	// ccmn Wd, Wn, #imm, <cond>  ····················································  (0 <= imm < 16)
	4, MatW, MatW, MatImm, MatCond, 0x5, 0x2e,
	// ccmn Xd, Xn, #imm, <cond>  ····················································  (0 <= imm < 16)
	4, MatX, MatX, MatImm, MatCond, 0x5, 0x3a,

	4,
	// ccmp Wd, #imm1, #imm2, <cond>  ·······························  (0 <= imm1 < 32, 0 <= imm2 < 16)
	4, MatW, MatImm, MatImm, MatCond, 0x5, 0x46,
	// ccmp Xd, #imm1, #imm2, <cond>  ·······························  (0 <= imm1 < 32, 0 <= imm2 < 16)
	4, MatX, MatImm, MatImm, MatCond, 0x5, 0x54,
	// ccmp Wd, Wn, #imm, <cond>  ····················································  (0 <= imm < 16)
	4, MatW, MatW, MatImm, MatCond, 0x5, 0x62,
	// ccmp Xd, Xn, #imm, <cond>  ····················································  (0 <= imm < 16)
	4, MatX, MatX, MatImm, MatCond, 0x5, 0x6e,

	1,
	// cfinv
	0, 0x5, 0x7a,

	1,
	// cfp RCTX, Xn
	2, MatLitSymbol, byte(RCTX), MatX, 0x5, 0x7f,

	2,
	// cinc Wd, Wn, <cond>
	3, MatW, MatW, MatCond, 0x5, 0x85,
	// cinc Xd, Xn, <cond>
	3, MatX, MatX, MatCond, 0x5, 0x90,

	2,
	// cinv Wd, Wn, <cond>
	3, MatW, MatW, MatCond, 0x5, 0x9b,
	// cinv Xd, Xn, <cond>
	3, MatX, MatX, MatCond, 0x5, 0xa6,

	2,
	// clrex #imm  ···································································  (0 <= imm < 16)
	1, MatImm, 0x5, 0xb1,
	// clrex
	0, 0x5, 0xb9,

	5,
	// cls Vd.16B, Vn.16B
	// cls Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x5, 0xbe,
	// cls Vd.8H, Vn.8H
	// cls Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x5, 0xc6,
	// cls Vd.4S, Vn.4S
	// cls Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x5, 0xce,
	// cls Wd, Wn
	2, MatW, MatW, 0x5, 0xd6,
	// cls Xd, Xn
	2, MatX, MatX, 0x5, 0xdd,

	5,
	// clz Vd.16B, Vn.16B
	// clz Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x5, 0xe4,
	// clz Vd.8H, Vn.8H
	// clz Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x5, 0xec,
	// clz Vd.4S, Vn.4S
	// clz Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x5, 0xf4,
	// clz Wd, Wn
	2, MatW, MatW, 0x5, 0xfc,
	// clz Xd, Xn
	2, MatX, MatX, 0x6, 0x3,

	10,
	// cmeq Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x6, 0xa,
	// cmeq Vd.16B, Vn.16B, Vm.16B
	// cmeq Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x6, 0x12,
	// cmeq Vd.8H, Vn.8H, Vm.8H
	// cmeq Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x6, 0x1b,
	// cmeq Vd.4S, Vn.4S, Vm.4S
	// cmeq Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x6, 0x24,
	// cmeq Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x6, 0x2d,
	// cmeq Dd, Dn, #0
	3, MatD, MatD, MatLitInt, 0, 0x6, 0x36,
	// cmeq Vd.16B, Vn.16B, #0
	// cmeq Vd.8B, Vn.8B, #0
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatLitInt, 0, 0x6, 0x3d,
	// cmeq Vd.8H, Vn.8H, #0
	// cmeq Vd.4H, Vn.4H, #0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitInt, 0, 0x6, 0x45,
	// cmeq Vd.4S, Vn.4S, #0
	// cmeq Vd.2S, Vn.2S, #0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitInt, 0, 0x6, 0x4d,
	// cmeq Vd.2D, Vn.2D, #0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitInt, 0, 0x6, 0x55,

	10,
	// cmge Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x6, 0x5d,
	// cmge Vd.16B, Vn.16B, Vm.16B
	// cmge Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x6, 0x65,
	// cmge Vd.8H, Vn.8H, Vm.8H
	// cmge Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x6, 0x6e,
	// cmge Vd.4S, Vn.4S, Vm.4S
	// cmge Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x6, 0x77,
	// cmge Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x6, 0x80,
	// cmge Dd, Dn, #0
	3, MatD, MatD, MatLitInt, 0, 0x6, 0x89,
	// cmge Vd.16B, Vn.16B, #0
	// cmge Vd.8B, Vn.8B, #0
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatLitInt, 0, 0x6, 0x90,
	// cmge Vd.8H, Vn.8H, #0
	// cmge Vd.4H, Vn.4H, #0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitInt, 0, 0x6, 0x98,
	// cmge Vd.4S, Vn.4S, #0
	// cmge Vd.2S, Vn.2S, #0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitInt, 0, 0x6, 0xa0,
	// cmge Vd.2D, Vn.2D, #0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitInt, 0, 0x6, 0xa8,

	10,
	// cmgt Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x6, 0xb0,
	// cmgt Vd.16B, Vn.16B, Vm.16B
	// cmgt Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x6, 0xb8,
	// cmgt Vd.8H, Vn.8H, Vm.8H
	// cmgt Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x6, 0xc1,
	// cmgt Vd.4S, Vn.4S, Vm.4S
	// cmgt Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x6, 0xca,
	// cmgt Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x6, 0xd3,
	// cmgt Dd, Dn, #0
	3, MatD, MatD, MatLitInt, 0, 0x6, 0xdc,
	// cmgt Vd.16B, Vn.16B, #0
	// cmgt Vd.8B, Vn.8B, #0
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatLitInt, 0, 0x6, 0xe3,
	// cmgt Vd.8H, Vn.8H, #0
	// cmgt Vd.4H, Vn.4H, #0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitInt, 0, 0x6, 0xeb,
	// cmgt Vd.4S, Vn.4S, #0
	// cmgt Vd.2S, Vn.2S, #0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitInt, 0, 0x6, 0xf3,
	// cmgt Vd.2D, Vn.2D, #0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitInt, 0, 0x6, 0xfb,

	5,
	// cmhi Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x7, 0x3,
	// cmhi Vd.16B, Vn.16B, Vm.16B
	// cmhi Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x7, 0xb,
	// cmhi Vd.8H, Vn.8H, Vm.8H
	// cmhi Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x7, 0x14,
	// cmhi Vd.4S, Vn.4S, Vm.4S
	// cmhi Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x7, 0x1d,
	// cmhi Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x7, 0x26,

	5,
	// cmhs Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x7, 0x2f,
	// cmhs Vd.16B, Vn.16B, Vm.16B
	// cmhs Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x7, 0x37,
	// cmhs Vd.8H, Vn.8H, Vm.8H
	// cmhs Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x7, 0x40,
	// cmhs Vd.4S, Vn.4S, Vm.4S
	// cmhs Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x7, 0x49,
	// cmhs Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x7, 0x52,

	5,
	// cmle Dd, Dn, #0
	3, MatD, MatD, MatLitInt, 0, 0x7, 0x5b,
	// cmle Vd.16B, Vn.16B, #0
	// cmle Vd.8B, Vn.8B, #0
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatLitInt, 0, 0x7, 0x62,
	// cmle Vd.8H, Vn.8H, #0
	// cmle Vd.4H, Vn.4H, #0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitInt, 0, 0x7, 0x6a,
	// cmle Vd.4S, Vn.4S, #0
	// cmle Vd.2S, Vn.2S, #0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitInt, 0, 0x7, 0x72,
	// cmle Vd.2D, Vn.2D, #0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitInt, 0, 0x7, 0x7a,

	5,
	// cmlt Dd, Dn, #0
	3, MatD, MatD, MatLitInt, 0, 0x7, 0x82,
	// cmlt Vd.16B, Vn.16B, #0
	// cmlt Vd.8B, Vn.8B, #0
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatLitInt, 0, 0x7, 0x89,
	// cmlt Vd.8H, Vn.8H, #0
	// cmlt Vd.4H, Vn.4H, #0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitInt, 0, 0x7, 0x91,
	// cmlt Vd.4S, Vn.4S, #0
	// cmlt Vd.2S, Vn.2S, #0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitInt, 0, 0x7, 0x99,
	// cmlt Vd.2D, Vn.2D, #0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitInt, 0, 0x7, 0xa1,

	7,
	// cmn Wd, Wn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 32)
	4, MatW, MatW, MatEnd, MatMod, SymShifts, 0x7, 0xa9,
	// cmn Xd, Xn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 64)
	4, MatX, MatX, MatEnd, MatMod, SymShifts, 0x7, 0xb4,
	// cmn Wd|WSP, Wn {, LSL|UXT[BHWX]|SXT[BHWX] #imm }  ·····························  (0 <= imm <= 4)
	4, MatWSP, MatW, MatEnd, MatMod, SymExtends, 0x7, 0xbf,
	// cmn Xd|SP, Wn, UXT[BHW]|SXT[BHW] #imm  ········································  (0 <= imm <= 4)
	3, MatXSP, MatW, MatMod, SymExtendsW, 0x7, 0xcb,
	// cmn Xd|SP, Xn {, LSL|UXTX|SXTX #imm }  ········································  (0 <= imm <= 4)
	4, MatXSP, MatX, MatEnd, MatMod, SymExtendsX, 0x7, 0xd7,
	// cmn Wd|WSP, #imm1 {, LSL #imm2 }  ·························  (0 <= imm1 < 4096, imm2 in [0, 12])
	4, MatWSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x7, 0xe3,
	// cmn Xd|SP, #imm1 {, LSL #imm2 }  ··························  (0 <= imm1 < 4096, imm2 in [0, 12])
	4, MatXSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x7, 0xef,

	7,
	// cmp Wd, Wn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 32)
	4, MatW, MatW, MatEnd, MatMod, SymShifts, 0x7, 0xfb,
	// cmp Xd, Xn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 64)
	4, MatX, MatX, MatEnd, MatMod, SymShifts, 0x8, 0x6,
	// cmp Wd|WSP, Wn {, LSL|UXT[BHWX]|SXT[BHWX] #imm }  ·····························  (0 <= imm <= 4)
	4, MatWSP, MatW, MatEnd, MatMod, SymExtends, 0x8, 0x11,
	// cmp Xd|SP, Wn, UXT[BHW]|SXT[BHW] #imm  ········································  (0 <= imm <= 4)
	3, MatXSP, MatW, MatMod, SymExtendsW, 0x8, 0x1d,
	// cmp Xd|SP, Xn {, LSL|UXTX|SXTX #imm }  ········································  (0 <= imm <= 4)
	4, MatXSP, MatX, MatEnd, MatMod, SymExtendsX, 0x8, 0x29,
	// cmp Wd|WSP, #imm1 {, LSL #imm2 }  ·························  (0 <= imm1 < 4096, imm2 in [0, 12])
	4, MatWSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x8, 0x35,
	// cmp Xd|SP, #imm1 {, LSL #imm2 }  ··························  (0 <= imm1 < 4096, imm2 in [0, 12])
	4, MatXSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x8, 0x41,

	5,
	// cmtst Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x8, 0x4d,
	// cmtst Vd.16B, Vn.16B, Vm.16B
	// cmtst Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x8, 0x55,
	// cmtst Vd.8H, Vn.8H, Vm.8H
	// cmtst Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x8, 0x5e,
	// cmtst Vd.4S, Vn.4S, Vm.4S
	// cmtst Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x8, 0x67,
	// cmtst Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x8, 0x70,

	2,
	// cneg Wd, Wn, <cond>
	3, MatW, MatW, MatCond, 0x8, 0x79,
	// cneg Xd, Xn, <cond>
	3, MatX, MatX, MatCond, 0x8, 0x84,

	1,
	// cnt Vd.16B, Vn.16B
	// cnt Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x8, 0x8f,

	1,
	// cpp RCTX, Xn
	2, MatLitSymbol, byte(RCTX), MatX, 0x8, 0x97,

	1,
	// crc32b Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x8, 0x9d,

	1,
	// crc32cb Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x8, 0xa5,

	1,
	// crc32ch Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x8, 0xad,

	1,
	// crc32cw Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x8, 0xb5,

	1,
	// crc32cx Wd, Wn, Xm
	3, MatW, MatW, MatX, 0x8, 0xbd,

	1,
	// crc32h Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x8, 0xc5,

	1,
	// crc32w Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x8, 0xcd,

	1,
	// crc32x Wd, Wn, Xm
	3, MatW, MatW, MatX, 0x8, 0xd5,

	1,
	// csdb
	0, 0x8, 0xdd,

	2,
	// csel Wd, Wn, Wm, <cond>
	4, MatW, MatW, MatW, MatCond, 0x8, 0xe2,
	// csel Xd, Xn, Xm, <cond>
	4, MatX, MatX, MatX, MatCond, 0x8, 0xec,

	2,
	// cset Wd, <cond>
	2, MatW, MatCond, 0x8, 0xf6,
	// cset Xd, <cond>
	2, MatX, MatCond, 0x8, 0xfe,

	2,
	// csetm Wd, <cond>
	2, MatW, MatCond, 0x9, 0x6,
	// csetm Xd, <cond>
	2, MatX, MatCond, 0x9, 0xe,

	2,
	// csinc Wd, Wn, Wm, <cond>
	4, MatW, MatW, MatW, MatCond, 0x9, 0x16,
	// csinc Xd, Xn, Xm, <cond>
	4, MatX, MatX, MatX, MatCond, 0x9, 0x20,

	2,
	// csinv Wd, Wn, Wm, <cond>
	4, MatW, MatW, MatW, MatCond, 0x9, 0x2a,
	// csinv Xd, Xn, Xm, <cond>
	4, MatX, MatX, MatX, MatCond, 0x9, 0x34,

	2,
	// csneg Wd, Wn, Wm, <cond>
	4, MatW, MatW, MatW, MatCond, 0x9, 0x3e,
	// csneg Xd, Xn, Xm, <cond>
	4, MatX, MatX, MatX, MatCond, 0x9, 0x48,

	1,
	// dc <symbol>, Xn
	2, MatSymbol, MatX, 0x9, 0x52,

	1,
	// dcps1  {, #imm }  ··························································  (0 <= imm < 65536)
	2, MatEnd, MatImm, 0x9, 0x5b,

	1,
	// dcps2  {, #imm }  ··························································  (0 <= imm < 65536)
	2, MatEnd, MatImm, 0x9, 0x63,

	1,
	// dcps3  {, #imm }  ··························································  (0 <= imm < 65536)
	2, MatEnd, MatImm, 0x9, 0x6b,

	2,
	// dmb <symbol>
	1, MatSymbol, 0x9, 0x73,
	// dmb #imm  ·····································································  (0 <= imm < 16)
	1, MatImm, 0x9, 0x7b,

	1,
	// drps
	0, 0x9, 0x83,

	2,
	// dsb <symbol>
	1, MatSymbol, 0x9, 0x88,
	// dsb #imm  ·····································································  (0 <= imm < 16)
	1, MatImm, 0x9, 0x90,

	12,
	// dup Bd, Vn.B[i]
	2, MatB, MatVElement, byte(BYTE), 0x9, 0x98,
	// dup Hd, Vn.H[i]
	2, MatH, MatVElement, byte(WORD), 0x9, 0xa2,
	// dup Sd, Vn.S[i]
	2, MatS, MatVElement, byte(DWORD), 0x9, 0xac,
	// dup Dd, Vn.D[i]
	2, MatD, MatVElement, byte(QWORD), 0x9, 0xb6,
	// dup Vd.16B, Vn.B[i]
	// dup Vd.8B, Vn.B[i]
	2, MatV, byte(BYTE), MatVElement, byte(BYTE), 0x9, 0xc0,
	// dup Vd.8H, Vn.H[i]
	// dup Vd.4H, Vn.H[i]
	2, MatV, byte(WORD), MatVElement, byte(WORD), 0x9, 0xcb,
	// dup Vd.4S, Vn.S[i]
	// dup Vd.2S, Vn.S[i]
	2, MatV, byte(DWORD), MatVElement, byte(DWORD), 0x9, 0xd6,
	// dup Vd.2D, Vn.D[i]
	2, MatVStatic, byte(QWORD), 2, MatVElement, byte(QWORD), 0x9, 0xe1,
	// dup Vd.16B, Wn
	// dup Vd.8B, Wn
	2, MatV, byte(BYTE), MatW, 0x9, 0xec,
	// dup Vd.8H, Wn
	// dup Vd.4H, Wn
	2, MatV, byte(WORD), MatW, 0x9, 0xf4,
	// dup Vd.4S, Wn
	// dup Vd.2S, Wn
	2, MatV, byte(DWORD), MatW, 0x9, 0xfc,
	// dup Vd.2D, Xn
	2, MatVStatic, byte(QWORD), 2, MatX, 0xa, 0x4,

	1,
	// dvp RCTX, Xn
	2, MatLitSymbol, byte(RCTX), MatX, 0xa, 0xc,

	2,
	// eon Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0xa, 0x12,
	// eon Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0xa, 0x1e,

	5,
	// eor Vd.16B, Vn.16B, Vm.16B
	// eor Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0xa, 0x2a,
	// eor Wd|WSP, Wn, #imm  ·················································  (imm is 32-bit logical)
	3, MatWSP, MatW, MatImm, 0xa, 0x33,
	// eor Xd|SP, Xn, #imm  ··················································  (imm is 64-bit logical)
	3, MatXSP, MatX, MatImm, 0xa, 0x3d,
	// eor Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0xa, 0x47,
	// eor Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0xa, 0x53,

	1,
	// eor3 Vd.16B, Vn.16B, Vm.16B, Va.16B
	4, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0xa, 0x5f,

	1,
	// eret
	0, 0xa, 0x68,

	1,
	// eretaa
	0, 0xa, 0x6d,

	1,
	// eretab
	0, 0xa, 0x72,

	1,
	// esb
	0, 0xa, 0x77,

	2,
	// ext Vd.8B, Vn.8B, Vm.8B, #imm  ·················································  (0 <= imm < 8)
	4, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, MatImm, 0xa, 0x7c,
	// ext Vd.16B, Vn.16B, Vm.16B, #imm  ·············································  (0 <= imm < 16)
	4, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, MatImm, 0xa, 0x87,

	2,
	// extr Wd, Wn, Wm, #imm  ························································  (0 <= imm < 32)
	4, MatW, MatW, MatW, MatImm, 0xa, 0x92,
	// extr Xd, Xn, Xm, #imm  ························································  (0 <= imm < 64)
	4, MatX, MatX, MatX, MatImm, 0xa, 0x9d,

	6,
	// fabd Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xa, 0xa8,
	// fabd Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xa, 0xb0,
	// fabd Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xa, 0xb8,
	// fabd Vd.8H, Vn.8H, Vm.8H
	// fabd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xa, 0xc0,
	// fabd Vd.4S, Vn.4S, Vm.4S
	// fabd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xa, 0xc9,
	// fabd Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xa, 0xd2,

	6,
	// fabs Vd.8H, Vn.8H
	// fabs Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0xa, 0xdb,
	// fabs Vd.4S, Vn.4S
	// fabs Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0xa, 0xe3,
	// fabs Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xa, 0xeb,
	// fabs Hd, Hn
	2, MatH, MatH, 0xa, 0xf3,
	// fabs Sd, Sn
	2, MatS, MatS, 0xa, 0xfa,
	// fabs Dd, Dn
	2, MatD, MatD, 0xb, 0x1,

	6,
	// facge Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xb, 0x8,
	// facge Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xb, 0x10,
	// facge Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xb, 0x18,
	// facge Vd.8H, Vn.8H, Vm.8H
	// facge Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xb, 0x20,
	// facge Vd.4S, Vn.4S, Vm.4S
	// facge Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xb, 0x29,
	// facge Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xb, 0x32,

	6,
	// facgt Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xb, 0x3b,
	// facgt Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xb, 0x43,
	// facgt Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xb, 0x4b,
	// facgt Vd.8H, Vn.8H, Vm.8H
	// facgt Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xb, 0x53,
	// facgt Vd.4S, Vn.4S, Vm.4S
	// facgt Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xb, 0x5c,
	// facgt Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xb, 0x65,

	6,
	// fadd Vd.8H, Vn.8H, Vm.8H
	// fadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xb, 0x6e,
	// fadd Vd.4S, Vn.4S, Vm.4S
	// fadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xb, 0x77,
	// fadd Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xb, 0x80,
	// fadd Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xb, 0x89,
	// fadd Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xb, 0x91,
	// fadd Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xb, 0x99,

	6,
	// faddp Hd, Vn.2H
	2, MatH, MatVStatic, byte(WORD), 2, 0xb, 0xa1,
	// faddp Sd, Vn.2S
	2, MatS, MatVStatic, byte(DWORD), 2, 0xb, 0xa8,
	// faddp Dd, Vn.2D
	2, MatD, MatVStatic, byte(QWORD), 2, 0xb, 0xaf,
	// faddp Vd.8H, Vn.8H, Vm.8H
	// faddp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xb, 0xb6,
	// faddp Vd.4S, Vn.4S, Vm.4S
	// faddp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xb, 0xbf,
	// faddp Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xb, 0xc8,

	3,
	// fcadd Vd.8H, Vn.8H, Vm.8H, #imm  ···········································  (imm in [90, 270])
	// fcadd Vd.4H, Vn.4H, Vm.4H, #imm  ···········································  (imm in [90, 270])
	4, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), MatImm, 0xb, 0xd1,
	// fcadd Vd.4S, Vn.4S, Vm.4S, #imm  ···········································  (imm in [90, 270])
	// fcadd Vd.2S, Vn.2S, Vm.2S, #imm  ···········································  (imm in [90, 270])
	4, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0xb, 0xdd,
	// fcadd Vd.2D, Vn.2D, Vm.2D, #imm  ···········································  (imm in [90, 270])
	4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0xb, 0xe9,

	3,
	// fccmp Hd, Hn, #imm, <cond>  ···················································  (0 <= imm < 16)
	4, MatH, MatH, MatImm, MatCond, 0xb, 0xf5,
	// fccmp Sd, Sn, #imm, <cond>  ···················································  (0 <= imm < 16)
	4, MatS, MatS, MatImm, MatCond, 0xc, 0x1,
	// fccmp Dd, Dn, #imm, <cond>  ···················································  (0 <= imm < 16)
	4, MatD, MatD, MatImm, MatCond, 0xc, 0xd,

	3,
	// fccmpe Hd, Hn, #imm, <cond>  ··················································  (0 <= imm < 16)
	4, MatH, MatH, MatImm, MatCond, 0xc, 0x19,
	// fccmpe Sd, Sn, #imm, <cond>  ··················································  (0 <= imm < 16)
	4, MatS, MatS, MatImm, MatCond, 0xc, 0x25,
	// fccmpe Dd, Dn, #imm, <cond>  ··················································  (0 <= imm < 16)
	4, MatD, MatD, MatImm, MatCond, 0xc, 0x31,

	12,
	// fcmeq Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xc, 0x3d,
	// fcmeq Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xc, 0x45,
	// fcmeq Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xc, 0x4d,
	// fcmeq Vd.8H, Vn.8H, Vm.8H
	// fcmeq Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xc, 0x55,
	// fcmeq Vd.4S, Vn.4S, Vm.4S
	// fcmeq Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xc, 0x5e,
	// fcmeq Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xc, 0x67,
	// fcmeq Hd, Hn, #0.0
	3, MatH, MatH, MatLitFloat, 0, 0xc, 0x70,
	// fcmeq Sd, Sn, #0.0
	3, MatS, MatS, MatLitFloat, 0, 0xc, 0x77,
	// fcmeq Dd, Dn, #0.0
	3, MatD, MatD, MatLitFloat, 0, 0xc, 0x7e,
	// fcmeq Vd.8H, Vn.8H, #0.0
	// fcmeq Vd.4H, Vn.4H, #0.0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitFloat, 0, 0xc, 0x85,
	// fcmeq Vd.4S, Vn.4S, #0.0
	// fcmeq Vd.2S, Vn.2S, #0.0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitFloat, 0, 0xc, 0x8d,
	// fcmeq Vd.2D, Vn.2D, #0.0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitFloat, 0, 0xc, 0x95,

	12,
	// fcmge Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xc, 0x9d,
	// fcmge Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xc, 0xa5,
	// fcmge Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xc, 0xad,
	// fcmge Vd.8H, Vn.8H, Vm.8H
	// fcmge Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xc, 0xb5,
	// fcmge Vd.4S, Vn.4S, Vm.4S
	// fcmge Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xc, 0xbe,
	// fcmge Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xc, 0xc7,
	// fcmge Hd, Hn, #0.0
	3, MatH, MatH, MatLitFloat, 0, 0xc, 0xd0,
	// fcmge Sd, Sn, #0.0
	3, MatS, MatS, MatLitFloat, 0, 0xc, 0xd7,
	// fcmge Dd, Dn, #0.0
	3, MatD, MatD, MatLitFloat, 0, 0xc, 0xde,
	// fcmge Vd.8H, Vn.8H, #0.0
	// fcmge Vd.4H, Vn.4H, #0.0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitFloat, 0, 0xc, 0xe5,
	// fcmge Vd.4S, Vn.4S, #0.0
	// fcmge Vd.2S, Vn.2S, #0.0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitFloat, 0, 0xc, 0xed,
	// fcmge Vd.2D, Vn.2D, #0.0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitFloat, 0, 0xc, 0xf5,

	12,
	// fcmgt Hd, Hn, Hm
	3, MatH, MatH, MatH, 0xc, 0xfd,
	// fcmgt Sd, Sn, Sm
	3, MatS, MatS, MatS, 0xd, 0x5,
	// fcmgt Dd, Dn, Dm
	3, MatD, MatD, MatD, 0xd, 0xd,
	// fcmgt Vd.8H, Vn.8H, Vm.8H
	// fcmgt Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0xd, 0x15,
	// fcmgt Vd.4S, Vn.4S, Vm.4S
	// fcmgt Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0xd, 0x1e,
	// fcmgt Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xd, 0x27,
	// fcmgt Hd, Hn, #0.0
	3, MatH, MatH, MatLitFloat, 0, 0xd, 0x30,
	// fcmgt Sd, Sn, #0.0
	3, MatS, MatS, MatLitFloat, 0, 0xd, 0x37,
	// fcmgt Dd, Dn, #0.0
	3, MatD, MatD, MatLitFloat, 0, 0xd, 0x3e,
	// fcmgt Vd.8H, Vn.8H, #0.0
	// fcmgt Vd.4H, Vn.4H, #0.0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitFloat, 0, 0xd, 0x45,
	// fcmgt Vd.4S, Vn.4S, #0.0
	// fcmgt Vd.2S, Vn.2S, #0.0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitFloat, 0, 0xd, 0x4d,
	// fcmgt Vd.2D, Vn.2D, #0.0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitFloat, 0, 0xd, 0x55,

	6,
	// fcmla Vd.4H, Vn.4H, Vm.H[i], #imm  ·································  (imm in [0, 90, 180, 270])
	4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), MatImm, 0xd, 0x5d,
	// fcmla Vd.8H, Vn.8H, Vm.H[i], #imm  ·································  (imm in [0, 90, 180, 270])
	4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), MatImm, 0xd, 0x69,
	// fcmla Vd.4S, Vn.4S, Vm.S[i], #imm  ·································  (imm in [0, 90, 180, 270])
	4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), MatImm, 0xd, 0x76,
	// fcmla Vd.8H, Vn.8H, Vm.8H, #imm  ···································  (imm in [0, 90, 180, 270])
	// fcmla Vd.4H, Vn.4H, Vm.4H, #imm  ···································  (imm in [0, 90, 180, 270])
	4, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), MatImm, 0xd, 0x84,
	// fcmla Vd.4S, Vn.4S, Vm.4S, #imm  ···································  (imm in [0, 90, 180, 270])
	// fcmla Vd.2S, Vn.2S, Vm.2S, #imm  ···································  (imm in [0, 90, 180, 270])
	4, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0xd, 0x90,
	// fcmla Vd.2D, Vn.2D, Vm.2D, #imm  ···································  (imm in [0, 90, 180, 270])
	4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0xd, 0x9c,

	6,
	// fcmle Hd, Hn, #0.0
	3, MatH, MatH, MatLitFloat, 0, 0xd, 0xa8,
	// fcmle Sd, Sn, #0.0
	3, MatS, MatS, MatLitFloat, 0, 0xd, 0xaf,
	// fcmle Dd, Dn, #0.0
	3, MatD, MatD, MatLitFloat, 0, 0xd, 0xb6,
	// fcmle Vd.8H, Vn.8H, #0.0
	// fcmle Vd.4H, Vn.4H, #0.0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitFloat, 0, 0xd, 0xbd,
	// fcmle Vd.4S, Vn.4S, #0.0
	// fcmle Vd.2S, Vn.2S, #0.0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitFloat, 0, 0xd, 0xc5,
	// fcmle Vd.2D, Vn.2D, #0.0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitFloat, 0, 0xd, 0xcd,

	6,
	// fcmlt Hd, Hn, #0.0
	3, MatH, MatH, MatLitFloat, 0, 0xd, 0xd5,
	// fcmlt Sd, Sn, #0.0
	3, MatS, MatS, MatLitFloat, 0, 0xd, 0xdc,
	// fcmlt Dd, Dn, #0.0
	3, MatD, MatD, MatLitFloat, 0, 0xd, 0xe3,
	// fcmlt Vd.8H, Vn.8H, #0.0
	// fcmlt Vd.4H, Vn.4H, #0.0
	3, MatV, byte(WORD), MatV, byte(WORD), MatLitFloat, 0, 0xd, 0xea,
	// fcmlt Vd.4S, Vn.4S, #0.0
	// fcmlt Vd.2S, Vn.2S, #0.0
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatLitFloat, 0, 0xd, 0xf2,
	// fcmlt Vd.2D, Vn.2D, #0.0
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatLitFloat, 0, 0xd, 0xfa,

	6,
	// fcmp Hd, Hn
	2, MatH, MatH, 0xe, 0x2,
	// fcmp Hd, #0.0
	2, MatH, MatLitFloat, 0, 0xe, 0x9,
	// fcmp Sd, Sn
	2, MatS, MatS, 0xe, 0xf,
	// fcmp Sd, #0.0
	2, MatS, MatLitFloat, 0, 0xe, 0x16,
	// fcmp Dd, Dn
	2, MatD, MatD, 0xe, 0x1c,
	// fcmp Dd, #0.0
	2, MatD, MatLitFloat, 0, 0xe, 0x23,

	6,
	// fcmpe Hd, Hn
	2, MatH, MatH, 0xe, 0x29,
	// fcmpe Hd, #0.0
	2, MatH, MatLitFloat, 0, 0xe, 0x30,
	// fcmpe Sd, Sn
	2, MatS, MatS, 0xe, 0x36,
	// fcmpe Sd, #0.0
	2, MatS, MatLitFloat, 0, 0xe, 0x3d,
	// fcmpe Dd, Dn
	2, MatD, MatD, 0xe, 0x43,
	// fcmpe Dd, #0.0
	2, MatD, MatLitFloat, 0, 0xe, 0x4a,

	3,
	// fcsel Hd, Hn, Hm, <cond>
	4, MatH, MatH, MatH, MatCond, 0xe, 0x50,
	// fcsel Sd, Sn, Sm, <cond>
	4, MatS, MatS, MatS, MatCond, 0xe, 0x5a,
	// fcsel Dd, Dn, Dm, <cond>
	4, MatD, MatD, MatD, MatCond, 0xe, 0x64,

	6,
	// fcvt Sd, Hn
	2, MatS, MatH, 0xe, 0x6e,
	// fcvt Dd, Hn
	2, MatD, MatH, 0xe, 0x75,
	// fcvt Hd, Sn
	2, MatH, MatS, 0xe, 0x7c,
	// fcvt Dd, Sn
	2, MatD, MatS, 0xe, 0x83,
	// fcvt Hd, Dn
	2, MatH, MatD, 0xe, 0x8a,
	// fcvt Sd, Dn
	2, MatS, MatD, 0xe, 0x91,

	12,
	// fcvtas Hd, Hn
	2, MatH, MatH, 0xe, 0x98,
	// fcvtas Sd, Sn
	2, MatS, MatS, 0xe, 0x9f,
	// fcvtas Dd, Dn
	2, MatD, MatD, 0xe, 0xa6,
	// fcvtas Vd.8H, Vn.8H
	// fcvtas Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0xe, 0xad,
	// fcvtas Vd.4S, Vn.4S
	// fcvtas Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0xe, 0xb5,
	// fcvtas Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xe, 0xbd,
	// fcvtas Wd, Hn
	2, MatW, MatH, 0xe, 0xc5,
	// fcvtas Xd, Hn
	2, MatX, MatH, 0xe, 0xcc,
	// fcvtas Wd, Sn
	2, MatW, MatS, 0xe, 0xd3,
	// fcvtas Xd, Sn
	2, MatX, MatS, 0xe, 0xda,
	// fcvtas Wd, Dn
	2, MatW, MatD, 0xe, 0xe1,
	// fcvtas Xd, Dn
	2, MatX, MatD, 0xe, 0xe8,

	12,
	// fcvtau Hd, Hn
	2, MatH, MatH, 0xe, 0xef,
	// fcvtau Sd, Sn
	2, MatS, MatS, 0xe, 0xf6,
	// fcvtau Dd, Dn
	2, MatD, MatD, 0xe, 0xfd,
	// fcvtau Vd.8H, Vn.8H
	// fcvtau Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0xf, 0x4,
	// fcvtau Vd.4S, Vn.4S
	// fcvtau Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0xf, 0xc,
	// fcvtau Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xf, 0x14,
	// fcvtau Wd, Hn
	2, MatW, MatH, 0xf, 0x1c,
	// fcvtau Xd, Hn
	2, MatX, MatH, 0xf, 0x23,
	// fcvtau Wd, Sn
	2, MatW, MatS, 0xf, 0x2a,
	// fcvtau Xd, Sn
	2, MatX, MatS, 0xf, 0x31,
	// fcvtau Wd, Dn
	2, MatW, MatD, 0xf, 0x38,
	// fcvtau Xd, Dn
	2, MatX, MatD, 0xf, 0x3f,

	2,
	// fcvtl Vd.4S, Vn.4H
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0xf, 0x46,
	// fcvtl Vd.2D, Vn.2S
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0xf, 0x4d,

	2,
	// fcvtl2 Vd.4S, Vn.8H
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0xf, 0x54,
	// fcvtl2 Vd.2D, Vn.4S
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0xf, 0x5b,

	12,
	// fcvtms Hd, Hn
	2, MatH, MatH, 0xf, 0x62,
	// fcvtms Sd, Sn
	2, MatS, MatS, 0xf, 0x69,
	// fcvtms Dd, Dn
	2, MatD, MatD, 0xf, 0x70,
	// fcvtms Vd.8H, Vn.8H
	// fcvtms Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0xf, 0x77,
	// fcvtms Vd.4S, Vn.4S
	// fcvtms Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0xf, 0x7f,
	// fcvtms Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xf, 0x87,
	// fcvtms Wd, Hn
	2, MatW, MatH, 0xf, 0x8f,
	// fcvtms Xd, Hn
	2, MatX, MatH, 0xf, 0x96,
	// fcvtms Wd, Sn
	2, MatW, MatS, 0xf, 0x9d,
	// fcvtms Xd, Sn
	2, MatX, MatS, 0xf, 0xa4,
	// fcvtms Wd, Dn
	2, MatW, MatD, 0xf, 0xab,
	// fcvtms Xd, Dn
	2, MatX, MatD, 0xf, 0xb2,

	12,
	// fcvtmu Hd, Hn
	2, MatH, MatH, 0xf, 0xb9,
	// fcvtmu Sd, Sn
	2, MatS, MatS, 0xf, 0xc0,
	// fcvtmu Dd, Dn
	2, MatD, MatD, 0xf, 0xc7,
	// fcvtmu Vd.8H, Vn.8H
	// fcvtmu Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0xf, 0xce,
	// fcvtmu Vd.4S, Vn.4S
	// fcvtmu Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0xf, 0xd6,
	// fcvtmu Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0xf, 0xde,
	// fcvtmu Wd, Hn
	2, MatW, MatH, 0xf, 0xe6,
	// fcvtmu Xd, Hn
	2, MatX, MatH, 0xf, 0xed,
	// fcvtmu Wd, Sn
	2, MatW, MatS, 0xf, 0xf4,
	// fcvtmu Xd, Sn
	2, MatX, MatS, 0xf, 0xfb,
	// fcvtmu Wd, Dn
	2, MatW, MatD, 0x10, 0x2,
	// fcvtmu Xd, Dn
	2, MatX, MatD, 0x10, 0x9,

	1,
	// fcvtn Vd.2S, Vn.2D
	2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, 0x10, 0x10,

	1,
	// fcvtn2 Vd.4S, Vn.2D
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, 0x10, 0x17,

	12,
	// fcvtns Hd, Hn
	2, MatH, MatH, 0x10, 0x1e,
	// fcvtns Sd, Sn
	2, MatS, MatS, 0x10, 0x25,
	// fcvtns Dd, Dn
	2, MatD, MatD, 0x10, 0x2c,
	// fcvtns Vd.8H, Vn.8H
	// fcvtns Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x10, 0x33,
	// fcvtns Vd.4S, Vn.4S
	// fcvtns Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x10, 0x3b,
	// fcvtns Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x10, 0x43,
	// fcvtns Wd, Hn
	2, MatW, MatH, 0x10, 0x4b,
	// fcvtns Xd, Hn
	2, MatX, MatH, 0x10, 0x52,
	// fcvtns Wd, Sn
	2, MatW, MatS, 0x10, 0x59,
	// fcvtns Xd, Sn
	2, MatX, MatS, 0x10, 0x60,
	// fcvtns Wd, Dn
	2, MatW, MatD, 0x10, 0x67,
	// fcvtns Xd, Dn
	2, MatX, MatD, 0x10, 0x6e,

	12,
	// fcvtnu Hd, Hn
	2, MatH, MatH, 0x10, 0x75,
	// fcvtnu Sd, Sn
	2, MatS, MatS, 0x10, 0x7c,
	// fcvtnu Dd, Dn
	2, MatD, MatD, 0x10, 0x83,
	// fcvtnu Vd.8H, Vn.8H
	// fcvtnu Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x10, 0x8a,
	// fcvtnu Vd.4S, Vn.4S
	// fcvtnu Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x10, 0x92,
	// fcvtnu Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x10, 0x9a,
	// fcvtnu Wd, Hn
	2, MatW, MatH, 0x10, 0xa2,
	// fcvtnu Xd, Hn
	2, MatX, MatH, 0x10, 0xa9,
	// fcvtnu Wd, Sn
	2, MatW, MatS, 0x10, 0xb0,
	// fcvtnu Xd, Sn
	2, MatX, MatS, 0x10, 0xb7,
	// fcvtnu Wd, Dn
	2, MatW, MatD, 0x10, 0xbe,
	// fcvtnu Xd, Dn
	2, MatX, MatD, 0x10, 0xc5,

	12,
	// fcvtps Hd, Hn
	2, MatH, MatH, 0x10, 0xcc,
	// fcvtps Sd, Sn
	2, MatS, MatS, 0x10, 0xd3,
	// fcvtps Dd, Dn
	2, MatD, MatD, 0x10, 0xda,
	// fcvtps Vd.8H, Vn.8H
	// fcvtps Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x10, 0xe1,
	// fcvtps Vd.4S, Vn.4S
	// fcvtps Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x10, 0xe9,
	// fcvtps Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x10, 0xf1,
	// fcvtps Wd, Hn
	2, MatW, MatH, 0x10, 0xf9,
	// fcvtps Xd, Hn
	2, MatX, MatH, 0x11, 0x0,
	// fcvtps Wd, Sn
	2, MatW, MatS, 0x11, 0x7,
	// fcvtps Xd, Sn
	2, MatX, MatS, 0x11, 0xe,
	// fcvtps Wd, Dn
	2, MatW, MatD, 0x11, 0x15,
	// fcvtps Xd, Dn
	2, MatX, MatD, 0x11, 0x1c,

	12,
	// fcvtpu Hd, Hn
	2, MatH, MatH, 0x11, 0x23,
	// fcvtpu Sd, Sn
	2, MatS, MatS, 0x11, 0x2a,
	// fcvtpu Dd, Dn
	2, MatD, MatD, 0x11, 0x31,
	// fcvtpu Vd.8H, Vn.8H
	// fcvtpu Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x11, 0x38,
	// fcvtpu Vd.4S, Vn.4S
	// fcvtpu Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x11, 0x40,
	// fcvtpu Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x11, 0x48,
	// fcvtpu Wd, Hn
	2, MatW, MatH, 0x11, 0x50,
	// fcvtpu Xd, Hn
	2, MatX, MatH, 0x11, 0x57,
	// fcvtpu Wd, Sn
	2, MatW, MatS, 0x11, 0x5e,
	// fcvtpu Xd, Sn
	2, MatX, MatS, 0x11, 0x65,
	// fcvtpu Wd, Dn
	2, MatW, MatD, 0x11, 0x6c,
	// fcvtpu Xd, Dn
	2, MatX, MatD, 0x11, 0x73,

	2,
	// fcvtxn Sd, Dn
	2, MatS, MatD, 0x11, 0x7a,
	// fcvtxn Vd.2S, Vn.2D
	2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, 0x11, 0x81,

	1,
	// fcvtxn2 Vd.4S, Vn.2D
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, 0x11, 0x88,

	24,
	// fcvtzs Hd, Hn, #imm  ··························································  (0 < imm <= 16)
	3, MatH, MatH, MatImm, 0x11, 0x8f,
	// fcvtzs Sd, Sn, #imm  ··························································  (0 < imm <= 32)
	3, MatS, MatS, MatImm, 0x11, 0x9c,
	// fcvtzs Dd, Dn, #imm  ··························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x11, 0xa9,
	// fcvtzs Vd.8H, Vn.8H, #imm  ····················································  (0 < imm <= 16)
	// fcvtzs Vd.4H, Vn.4H, #imm  ····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x11, 0xb6,
	// fcvtzs Vd.4S, Vn.4S, #imm  ····················································  (0 < imm <= 32)
	// fcvtzs Vd.2S, Vn.2S, #imm  ····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x11, 0xc2,
	// fcvtzs Vd.2D, Vn.2D, #imm  ····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x11, 0xce,
	// fcvtzs Hd, Hn
	2, MatH, MatH, 0x11, 0xda,
	// fcvtzs Sd, Sn
	2, MatS, MatS, 0x11, 0xe1,
	// fcvtzs Dd, Dn
	2, MatD, MatD, 0x11, 0xe8,
	// fcvtzs Vd.8H, Vn.8H
	// fcvtzs Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x11, 0xef,
	// fcvtzs Vd.4S, Vn.4S
	// fcvtzs Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x11, 0xf7,
	// fcvtzs Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x11, 0xff,
	// fcvtzs Wd, Hn, #imm  ··························································  (0 < imm <= 32)
	3, MatW, MatH, MatImm, 0x12, 0x7,
	// fcvtzs Xd, Hn, #imm  ··························································  (0 < imm <= 64)
	3, MatX, MatH, MatImm, 0x12, 0x14,
	// fcvtzs Wd, Sn, #imm  ··························································  (0 < imm <= 32)
	3, MatW, MatS, MatImm, 0x12, 0x1f,
	// fcvtzs Xd, Sn, #imm  ··························································  (0 < imm <= 64)
	3, MatX, MatS, MatImm, 0x12, 0x2c,
	// fcvtzs Wd, Dn, #imm  ··························································  (0 < imm <= 32)
	3, MatW, MatD, MatImm, 0x12, 0x37,
	// fcvtzs Xd, Dn, #imm  ··························································  (0 < imm <= 64)
	3, MatX, MatD, MatImm, 0x12, 0x44,
	// fcvtzs Wd, Hn
	2, MatW, MatH, 0x12, 0x4f,
	// fcvtzs Xd, Hn
	2, MatX, MatH, 0x12, 0x56,
	// fcvtzs Wd, Sn
	2, MatW, MatS, 0x12, 0x5d,
	// fcvtzs Xd, Sn
	2, MatX, MatS, 0x12, 0x64,
	// fcvtzs Wd, Dn
	2, MatW, MatD, 0x12, 0x6b,
	// fcvtzs Xd, Dn
	2, MatX, MatD, 0x12, 0x72,

	24,
	// fcvtzu Hd, Hn, #imm  ··························································  (0 < imm <= 16)
	3, MatH, MatH, MatImm, 0x12, 0x79,
	// fcvtzu Sd, Sn, #imm  ··························································  (0 < imm <= 32)
	3, MatS, MatS, MatImm, 0x12, 0x86,
	// fcvtzu Dd, Dn, #imm  ··························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x12, 0x93,
	// fcvtzu Vd.8H, Vn.8H, #imm  ····················································  (0 < imm <= 16)
	// fcvtzu Vd.4H, Vn.4H, #imm  ····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x12, 0xa0,
	// fcvtzu Vd.4S, Vn.4S, #imm  ····················································  (0 < imm <= 32)
	// fcvtzu Vd.2S, Vn.2S, #imm  ····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x12, 0xac,
	// fcvtzu Vd.2D, Vn.2D, #imm  ····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x12, 0xb8,
	// fcvtzu Hd, Hn
	2, MatH, MatH, 0x12, 0xc4,
	// fcvtzu Sd, Sn
	2, MatS, MatS, 0x12, 0xcb,
	// fcvtzu Dd, Dn
	2, MatD, MatD, 0x12, 0xd2,
	// fcvtzu Vd.8H, Vn.8H
	// fcvtzu Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x12, 0xd9,
	// fcvtzu Vd.4S, Vn.4S
	// fcvtzu Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x12, 0xe1,
	// fcvtzu Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x12, 0xe9,
	// fcvtzu Wd, Hn, #imm  ··························································  (0 < imm <= 32)
	3, MatW, MatH, MatImm, 0x12, 0xf1,
	// fcvtzu Xd, Hn, #imm  ··························································  (0 < imm <= 64)
	3, MatX, MatH, MatImm, 0x12, 0xfe,
	// fcvtzu Wd, Sn, #imm  ··························································  (0 < imm <= 32)
	3, MatW, MatS, MatImm, 0x13, 0x9,
	// fcvtzu Xd, Sn, #imm  ··························································  (0 < imm <= 64)
	3, MatX, MatS, MatImm, 0x13, 0x16,
	// fcvtzu Wd, Dn, #imm  ··························································  (0 < imm <= 32)
	3, MatW, MatD, MatImm, 0x13, 0x21,
	// fcvtzu Xd, Dn, #imm  ··························································  (0 < imm <= 64)
	3, MatX, MatD, MatImm, 0x13, 0x2e,
	// fcvtzu Wd, Hn
	2, MatW, MatH, 0x13, 0x39,
	// fcvtzu Xd, Hn
	2, MatX, MatH, 0x13, 0x40,
	// fcvtzu Wd, Sn
	2, MatW, MatS, 0x13, 0x47,
	// fcvtzu Xd, Sn
	2, MatX, MatS, 0x13, 0x4e,
	// fcvtzu Wd, Dn
	2, MatW, MatD, 0x13, 0x55,
	// fcvtzu Xd, Dn
	2, MatX, MatD, 0x13, 0x5c,

	6,
	// fdiv Vd.8H, Vn.8H, Vm.8H
	// fdiv Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x13, 0x63,
	// fdiv Vd.4S, Vn.4S, Vm.4S
	// fdiv Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x13, 0x6c,
	// fdiv Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x13, 0x75,
	// fdiv Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x13, 0x7e,
	// fdiv Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x13, 0x86,
	// fdiv Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x13, 0x8e,

	1,
	// fjcvtzs Wd, Dn
	2, MatW, MatD, 0x13, 0x96,

	3,
	// fmadd Hd, Hn, Hm, Ha
	4, MatH, MatH, MatH, MatH, 0x13, 0x9d,
	// fmadd Sd, Sn, Sm, Sa
	4, MatS, MatS, MatS, MatS, 0x13, 0xa6,
	// fmadd Dd, Dn, Dm, Da
	4, MatD, MatD, MatD, MatD, 0x13, 0xaf,

	6,
	// fmax Vd.8H, Vn.8H, Vm.8H
	// fmax Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x13, 0xb8,
	// fmax Vd.4S, Vn.4S, Vm.4S
	// fmax Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x13, 0xc1,
	// fmax Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x13, 0xca,
	// fmax Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x13, 0xd3,
	// fmax Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x13, 0xdb,
	// fmax Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x13, 0xe3,

	6,
	// fmaxnm Vd.8H, Vn.8H, Vm.8H
	// fmaxnm Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x13, 0xeb,
	// fmaxnm Vd.4S, Vn.4S, Vm.4S
	// fmaxnm Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x13, 0xf4,
	// fmaxnm Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x13, 0xfd,
	// fmaxnm Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x14, 0x6,
	// fmaxnm Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x14, 0xe,
	// fmaxnm Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x14, 0x16,

	6,
	// fmaxnmp Hd, Vn.2H
	2, MatH, MatVStatic, byte(WORD), 2, 0x14, 0x1e,
	// fmaxnmp Sd, Vn.2S
	2, MatS, MatVStatic, byte(DWORD), 2, 0x14, 0x25,
	// fmaxnmp Dd, Vn.2D
	2, MatD, MatVStatic, byte(QWORD), 2, 0x14, 0x2c,
	// fmaxnmp Vd.8H, Vn.8H, Vm.8H
	// fmaxnmp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x14, 0x33,
	// fmaxnmp Vd.4S, Vn.4S, Vm.4S
	// fmaxnmp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x14, 0x3c,
	// fmaxnmp Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x14, 0x45,

	2,
	// fmaxnmv Hd, Vn.8H
	// fmaxnmv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x14, 0x4e,
	// fmaxnmv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x14, 0x56,

	6,
	// fmaxp Hd, Vn.2H
	2, MatH, MatVStatic, byte(WORD), 2, 0x14, 0x5e,
	// fmaxp Sd, Vn.2S
	2, MatS, MatVStatic, byte(DWORD), 2, 0x14, 0x65,
	// fmaxp Dd, Vn.2D
	2, MatD, MatVStatic, byte(QWORD), 2, 0x14, 0x6c,
	// fmaxp Vd.8H, Vn.8H, Vm.8H
	// fmaxp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x14, 0x73,
	// fmaxp Vd.4S, Vn.4S, Vm.4S
	// fmaxp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x14, 0x7c,
	// fmaxp Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x14, 0x85,

	2,
	// fmaxv Hd, Vn.8H
	// fmaxv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x14, 0x8e,
	// fmaxv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x14, 0x96,

	6,
	// fmin Vd.8H, Vn.8H, Vm.8H
	// fmin Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x14, 0x9e,
	// fmin Vd.4S, Vn.4S, Vm.4S
	// fmin Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x14, 0xa7,
	// fmin Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x14, 0xb0,
	// fmin Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x14, 0xb9,
	// fmin Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x14, 0xc1,
	// fmin Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x14, 0xc9,

	6,
	// fminnm Vd.8H, Vn.8H, Vm.8H
	// fminnm Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x14, 0xd1,
	// fminnm Vd.4S, Vn.4S, Vm.4S
	// fminnm Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x14, 0xda,
	// fminnm Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x14, 0xe3,
	// fminnm Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x14, 0xec,
	// fminnm Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x14, 0xf4,
	// fminnm Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x14, 0xfc,

	6,
	// fminnmp Hd, Vn.2H
	2, MatH, MatVStatic, byte(WORD), 2, 0x15, 0x4,
	// fminnmp Sd, Vn.2S
	2, MatS, MatVStatic, byte(DWORD), 2, 0x15, 0xb,
	// fminnmp Dd, Vn.2D
	2, MatD, MatVStatic, byte(QWORD), 2, 0x15, 0x12,
	// fminnmp Vd.8H, Vn.8H, Vm.8H
	// fminnmp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x15, 0x19,
	// fminnmp Vd.4S, Vn.4S, Vm.4S
	// fminnmp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x15, 0x22,
	// fminnmp Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x15, 0x2b,

	2,
	// fminnmv Hd, Vn.8H
	// fminnmv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x15, 0x34,
	// fminnmv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x15, 0x3c,

	6,
	// fminp Hd, Vn.2H
	2, MatH, MatVStatic, byte(WORD), 2, 0x15, 0x44,
	// fminp Sd, Vn.2S
	2, MatS, MatVStatic, byte(DWORD), 2, 0x15, 0x4b,
	// fminp Dd, Vn.2D
	2, MatD, MatVStatic, byte(QWORD), 2, 0x15, 0x52,
	// fminp Vd.8H, Vn.8H, Vm.8H
	// fminp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x15, 0x59,
	// fminp Vd.4S, Vn.4S, Vm.4S
	// fminp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x15, 0x62,
	// fminp Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x15, 0x6b,

	2,
	// fminv Hd, Vn.8H
	// fminv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x15, 0x74,
	// fminv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x15, 0x7c,

	9,
	// fmla Hd, Hn, Vm.H[i]  ································································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x15, 0x84,
	// fmla Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x15, 0x8e,
	// fmla Dd, Dn, Vm.D[i]
	3, MatD, MatD, MatVElement, byte(QWORD), 0x15, 0x98,
	// fmla Vd.8H, Vn.8H, Vm.H[i]  ··························································  (m < 16)
	// fmla Vd.4H, Vn.4H, Vm.H[i]  ··························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x15, 0xa2,
	// fmla Vd.4S, Vn.4S, Vm.S[i]
	// fmla Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x15, 0xad,
	// fmla Vd.2D, Vn.2D, Vm.D[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVElement, byte(QWORD), 0x15, 0xb8,
	// fmla Vd.8H, Vn.8H, Vm.8H
	// fmla Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x15, 0xc3,
	// fmla Vd.4S, Vn.4S, Vm.4S
	// fmla Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x15, 0xcc,
	// fmla Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x15, 0xd5,

	4,
	// fmlal Vd.2S, Vn.2H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVElement, byte(WORD), 0x15, 0xde,
	// fmlal Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x15, 0xe8,
	// fmlal Vd.2S, Vn.2H, Vm.2H
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVStatic, byte(WORD), 2, 0x15, 0xf2,
	// fmlal Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x15, 0xfa,

	4,
	// fmlal2 Vd.2S, Vn.2H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVElement, byte(WORD), 0x16, 0x2,
	// fmlal2 Vd.4S, Vn.4H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x16, 0xc,
	// fmlal2 Vd.2S, Vn.2H, Vm.2H
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVStatic, byte(WORD), 2, 0x16, 0x16,
	// fmlal2 Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x16, 0x1e,

	9,
	// fmls Hd, Hn, Vm.H[i]  ································································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x16, 0x26,
	// fmls Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x16, 0x30,
	// fmls Dd, Dn, Vm.D[i]
	3, MatD, MatD, MatVElement, byte(QWORD), 0x16, 0x3a,
	// fmls Vd.8H, Vn.8H, Vm.H[i]  ··························································  (m < 16)
	// fmls Vd.4H, Vn.4H, Vm.H[i]  ··························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x16, 0x44,
	// fmls Vd.4S, Vn.4S, Vm.S[i]
	// fmls Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x16, 0x4f,
	// fmls Vd.2D, Vn.2D, Vm.D[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVElement, byte(QWORD), 0x16, 0x5a,
	// fmls Vd.8H, Vn.8H, Vm.8H
	// fmls Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x16, 0x65,
	// fmls Vd.4S, Vn.4S, Vm.4S
	// fmls Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x16, 0x6e,
	// fmls Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x16, 0x77,

	4,
	// fmlsl Vd.2S, Vn.2H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVElement, byte(WORD), 0x16, 0x80,
	// fmlsl Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x16, 0x8a,
	// fmlsl Vd.2S, Vn.2H, Vm.2H
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVStatic, byte(WORD), 2, 0x16, 0x94,
	// fmlsl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x16, 0x9c,

	4,
	// fmlsl2 Vd.2S, Vn.2H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVElement, byte(WORD), 0x16, 0xa4,
	// fmlsl2 Vd.4S, Vn.4H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x16, 0xae,
	// fmlsl2 Vd.2S, Vn.2H, Vm.2H
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(WORD), 2, MatVStatic, byte(WORD), 2, 0x16, 0xb8,
	// fmlsl2 Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x16, 0xc0,

	19,
	// fmov Vd.8H, #imm  ························································  (imm is split float)
	// fmov Vd.4H, #imm  ························································  (imm is split float)
	2, MatV, byte(WORD), MatFloat, 0x16, 0xc8,
	// fmov Vd.4S, #imm  ························································  (imm is split float)
	// fmov Vd.2S, #imm  ························································  (imm is split float)
	2, MatV, byte(DWORD), MatFloat, 0x16, 0xd2,
	// fmov Vd.2D, #imm  ························································  (imm is split float)
	2, MatVStatic, byte(QWORD), 2, MatFloat, 0x16, 0xdc,
	// fmov Hd, Hn
	2, MatH, MatH, 0x16, 0xe5,
	// fmov Sd, Sn
	2, MatS, MatS, 0x16, 0xec,
	// fmov Dd, Dn
	2, MatD, MatD, 0x16, 0xf3,
	// fmov Wd, Hn
	2, MatW, MatH, 0x16, 0xfa,
	// fmov Xd, Hn
	2, MatX, MatH, 0x17, 0x1,
	// fmov Hd, Wn
	2, MatH, MatW, 0x17, 0x8,
	// fmov Sd, Wn
	2, MatS, MatW, 0x17, 0xf,
	// fmov Wd, Sn
	2, MatW, MatS, 0x17, 0x16,
	// fmov Hd, Xn
	2, MatH, MatX, 0x17, 0x1d,
	// fmov Dd, Xn
	2, MatD, MatX, 0x17, 0x24,
	// fmov Vd.D[1], Xn
	2, MatVElementStatic, byte(QWORD), 1, MatX, 0x17, 0x2b,
	// fmov Xd, Dn
	2, MatX, MatD, 0x17, 0x32,
	// fmov Xd, Vn.D[1]
	2, MatX, MatVElementStatic, byte(QWORD), 1, 0x17, 0x39,
	// fmov Hd, #imm  ·································································  (imm is float)
	2, MatH, MatFloat, 0x17, 0x40,
	// fmov Sd, #imm  ·································································  (imm is float)
	2, MatS, MatFloat, 0x17, 0x49,
	// fmov Dd, #imm  ·································································  (imm is float)
	2, MatD, MatFloat, 0x17, 0x52,

	3,
	// fmsub Hd, Hn, Hm, Ha
	4, MatH, MatH, MatH, MatH, 0x17, 0x5b,
	// fmsub Sd, Sn, Sm, Sa
	4, MatS, MatS, MatS, MatS, 0x17, 0x64,
	// fmsub Dd, Dn, Dm, Da
	4, MatD, MatD, MatD, MatD, 0x17, 0x6d,

	12,
	// fmul Hd, Hn, Vm.H[i]  ································································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x17, 0x76,
	// fmul Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x17, 0x80,
	// fmul Dd, Dn, Vm.D[i]
	3, MatD, MatD, MatVElement, byte(QWORD), 0x17, 0x8a,
	// fmul Vd.8H, Vn.8H, Vm.H[i]  ··························································  (m < 16)
	// fmul Vd.4H, Vn.4H, Vm.H[i]  ··························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x17, 0x94,
	// fmul Vd.4S, Vn.4S, Vm.S[i]
	// fmul Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x17, 0x9f,
	// fmul Vd.2D, Vn.2D, Vm.D[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVElement, byte(QWORD), 0x17, 0xaa,
	// fmul Vd.8H, Vn.8H, Vm.8H
	// fmul Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x17, 0xb5,
	// fmul Vd.4S, Vn.4S, Vm.4S
	// fmul Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x17, 0xbe,
	// fmul Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x17, 0xc7,
	// fmul Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x17, 0xd0,
	// fmul Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x17, 0xd8,
	// fmul Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x17, 0xe0,

	12,
	// fmulx Hd, Hn, Vm.H[i]  ·······························································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x17, 0xe8,
	// fmulx Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x17, 0xf2,
	// fmulx Dd, Dn, Vm.D[i]
	3, MatD, MatD, MatVElement, byte(QWORD), 0x17, 0xfc,
	// fmulx Vd.8H, Vn.8H, Vm.H[i]  ·························································  (m < 16)
	// fmulx Vd.4H, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x18, 0x6,
	// fmulx Vd.4S, Vn.4S, Vm.S[i]
	// fmulx Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x18, 0x11,
	// fmulx Vd.2D, Vn.2D, Vm.D[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVElement, byte(QWORD), 0x18, 0x1c,
	// fmulx Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x18, 0x27,
	// fmulx Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x18, 0x2f,
	// fmulx Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x18, 0x37,
	// fmulx Vd.8H, Vn.8H, Vm.8H
	// fmulx Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x18, 0x3f,
	// fmulx Vd.4S, Vn.4S, Vm.4S
	// fmulx Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x18, 0x48,
	// fmulx Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x18, 0x51,

	6,
	// fneg Vd.8H, Vn.8H
	// fneg Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x18, 0x5a,
	// fneg Vd.4S, Vn.4S
	// fneg Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x18, 0x62,
	// fneg Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x18, 0x6a,
	// fneg Hd, Hn
	2, MatH, MatH, 0x18, 0x72,
	// fneg Sd, Sn
	2, MatS, MatS, 0x18, 0x79,
	// fneg Dd, Dn
	2, MatD, MatD, 0x18, 0x80,

	3,
	// fnmadd Hd, Hn, Hm, Ha
	4, MatH, MatH, MatH, MatH, 0x18, 0x87,
	// fnmadd Sd, Sn, Sm, Sa
	4, MatS, MatS, MatS, MatS, 0x18, 0x90,
	// fnmadd Dd, Dn, Dm, Da
	4, MatD, MatD, MatD, MatD, 0x18, 0x99,

	3,
	// fnmsub Hd, Hn, Hm, Ha
	4, MatH, MatH, MatH, MatH, 0x18, 0xa2,
	// fnmsub Sd, Sn, Sm, Sa
	4, MatS, MatS, MatS, MatS, 0x18, 0xab,
	// fnmsub Dd, Dn, Dm, Da
	4, MatD, MatD, MatD, MatD, 0x18, 0xb4,

	3,
	// fnmul Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x18, 0xbd,
	// fnmul Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x18, 0xc5,
	// fnmul Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x18, 0xcd,

	6,
	// frecpe Hd, Hn
	2, MatH, MatH, 0x18, 0xd5,
	// frecpe Sd, Sn
	2, MatS, MatS, 0x18, 0xdc,
	// frecpe Dd, Dn
	2, MatD, MatD, 0x18, 0xe3,
	// frecpe Vd.8H, Vn.8H
	// frecpe Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x18, 0xea,
	// frecpe Vd.4S, Vn.4S
	// frecpe Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x18, 0xf2,
	// frecpe Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x18, 0xfa,

	6,
	// frecps Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x19, 0x2,
	// frecps Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x19, 0xa,
	// frecps Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x19, 0x12,
	// frecps Vd.8H, Vn.8H, Vm.8H
	// frecps Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x19, 0x1a,
	// frecps Vd.4S, Vn.4S, Vm.4S
	// frecps Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x19, 0x23,
	// frecps Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x19, 0x2c,

	3,
	// frecpx Hd, Hn
	2, MatH, MatH, 0x19, 0x35,
	// frecpx Sd, Sn
	2, MatS, MatS, 0x19, 0x3c,
	// frecpx Dd, Dn
	2, MatD, MatD, 0x19, 0x43,

	6,
	// frinta Vd.8H, Vn.8H
	// frinta Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x19, 0x4a,
	// frinta Vd.4S, Vn.4S
	// frinta Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x19, 0x52,
	// frinta Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x19, 0x5a,
	// frinta Hd, Hn
	2, MatH, MatH, 0x19, 0x62,
	// frinta Sd, Sn
	2, MatS, MatS, 0x19, 0x69,
	// frinta Dd, Dn
	2, MatD, MatD, 0x19, 0x70,

	6,
	// frinti Vd.8H, Vn.8H
	// frinti Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x19, 0x77,
	// frinti Vd.4S, Vn.4S
	// frinti Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x19, 0x7f,
	// frinti Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x19, 0x87,
	// frinti Hd, Hn
	2, MatH, MatH, 0x19, 0x8f,
	// frinti Sd, Sn
	2, MatS, MatS, 0x19, 0x96,
	// frinti Dd, Dn
	2, MatD, MatD, 0x19, 0x9d,

	6,
	// frintm Vd.8H, Vn.8H
	// frintm Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x19, 0xa4,
	// frintm Vd.4S, Vn.4S
	// frintm Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x19, 0xac,
	// frintm Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x19, 0xb4,
	// frintm Hd, Hn
	2, MatH, MatH, 0x19, 0xbc,
	// frintm Sd, Sn
	2, MatS, MatS, 0x19, 0xc3,
	// frintm Dd, Dn
	2, MatD, MatD, 0x19, 0xca,

	6,
	// frintn Vd.8H, Vn.8H
	// frintn Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x19, 0xd1,
	// frintn Vd.4S, Vn.4S
	// frintn Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x19, 0xd9,
	// frintn Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x19, 0xe1,
	// frintn Hd, Hn
	2, MatH, MatH, 0x19, 0xe9,
	// frintn Sd, Sn
	2, MatS, MatS, 0x19, 0xf0,
	// frintn Dd, Dn
	2, MatD, MatD, 0x19, 0xf7,

	6,
	// frintp Vd.8H, Vn.8H
	// frintp Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x19, 0xfe,
	// frintp Vd.4S, Vn.4S
	// frintp Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x1a, 0x6,
	// frintp Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1a, 0xe,
	// frintp Hd, Hn
	2, MatH, MatH, 0x1a, 0x16,
	// frintp Sd, Sn
	2, MatS, MatS, 0x1a, 0x1d,
	// frintp Dd, Dn
	2, MatD, MatD, 0x1a, 0x24,

	6,
	// frintx Vd.8H, Vn.8H
	// frintx Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x1a, 0x2b,
	// frintx Vd.4S, Vn.4S
	// frintx Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x1a, 0x33,
	// frintx Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1a, 0x3b,
	// frintx Hd, Hn
	2, MatH, MatH, 0x1a, 0x43,
	// frintx Sd, Sn
	2, MatS, MatS, 0x1a, 0x4a,
	// frintx Dd, Dn
	2, MatD, MatD, 0x1a, 0x51,

	6,
	// frintz Vd.8H, Vn.8H
	// frintz Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x1a, 0x58,
	// frintz Vd.4S, Vn.4S
	// frintz Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x1a, 0x60,
	// frintz Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1a, 0x68,
	// frintz Hd, Hn
	2, MatH, MatH, 0x1a, 0x70,
	// frintz Sd, Sn
	2, MatS, MatS, 0x1a, 0x77,
	// frintz Dd, Dn
	2, MatD, MatD, 0x1a, 0x7e,

	6,
	// frsqrte Hd, Hn
	2, MatH, MatH, 0x1a, 0x85,
	// frsqrte Sd, Sn
	2, MatS, MatS, 0x1a, 0x8c,
	// frsqrte Dd, Dn
	2, MatD, MatD, 0x1a, 0x93,
	// frsqrte Vd.8H, Vn.8H
	// frsqrte Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x1a, 0x9a,
	// frsqrte Vd.4S, Vn.4S
	// frsqrte Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x1a, 0xa2,
	// frsqrte Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1a, 0xaa,

	6,
	// frsqrts Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x1a, 0xb2,
	// frsqrts Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x1a, 0xba,
	// frsqrts Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x1a, 0xc2,
	// frsqrts Vd.8H, Vn.8H, Vm.8H
	// frsqrts Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x1a, 0xca,
	// frsqrts Vd.4S, Vn.4S, Vm.4S
	// frsqrts Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x1a, 0xd3,
	// frsqrts Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1a, 0xdc,

	6,
	// fsqrt Vd.8H, Vn.8H
	// fsqrt Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x1a, 0xe5,
	// fsqrt Vd.4S, Vn.4S
	// fsqrt Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x1a, 0xed,
	// fsqrt Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1a, 0xf5,
	// fsqrt Hd, Hn
	2, MatH, MatH, 0x1a, 0xfd,
	// fsqrt Sd, Sn
	2, MatS, MatS, 0x1b, 0x4,
	// fsqrt Dd, Dn
	2, MatD, MatD, 0x1b, 0xb,

	6,
	// fsub Vd.8H, Vn.8H, Vm.8H
	// fsub Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x1b, 0x12,
	// fsub Vd.4S, Vn.4S, Vm.4S
	// fsub Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x1b, 0x1b,
	// fsub Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x1b, 0x24,
	// fsub Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x1b, 0x2d,
	// fsub Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x1b, 0x35,
	// fsub Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x1b, 0x3d,

	1,
	// hint #imm  ···································································  (0 <= imm < 128)
	1, MatImm, 0x1b, 0x45,

	1,
	// hlt #imm  ··································································  (0 <= imm < 65536)
	1, MatImm, 0x1b, 0x4d,

	1,
	// hvc #imm  ··································································  (0 <= imm < 65536)
	1, MatImm, 0x1b, 0x55,

	2,
	// ic IVAU, Xn
	2, MatLitSymbol, byte(IVAU), MatX, 0x1b, 0x5d,
	// ic <symbol>
	1, MatSymbol, 0x1b, 0x63,

	8,
	// ins Vd.B[i], Vn.B[i]
	2, MatVElement, byte(BYTE), MatVElement, byte(BYTE), 0x1b, 0x6b,
	// ins Vd.H[i], Vn.H[i]
	2, MatVElement, byte(WORD), MatVElement, byte(WORD), 0x1b, 0x78,
	// ins Vd.S[i], Vn.S[i]
	2, MatVElement, byte(DWORD), MatVElement, byte(DWORD), 0x1b, 0x85,
	// ins Vd.D[i], Vn.D[i]
	2, MatVElement, byte(QWORD), MatVElement, byte(QWORD), 0x1b, 0x92,
	// ins Vd.B[i], Wn
	2, MatVElement, byte(BYTE), MatW, 0x1b, 0x9f,
	// ins Vd.H[i], Wn
	2, MatVElement, byte(WORD), MatW, 0x1b, 0xa9,
	// ins Vd.S[i], Wn
	2, MatVElement, byte(DWORD), MatW, 0x1b, 0xb3,
	// ins Vd.D[i], Xn
	2, MatVElement, byte(QWORD), MatX, 0x1b, 0xbd,

	3,
	// isb SY
	1, MatLitSymbol, byte(SY), 0x1b, 0xc7,
	// isb #imm  ·····································································  (0 <= imm < 16)
	1, MatImm, 0x1b, 0xcc,
	// isb
	0, 0x1b, 0xd4,

	76,
	// ld1 {Vd.16B * 1}, [Xn|SP]
	// ld1 {Vd.8B * 1}, [Xn|SP]
	2, MatRegList, 1, byte(BYTE), MatRefBase, 0x1b, 0xd9,
	// ld1 {Vd.8H * 1}, [Xn|SP]
	// ld1 {Vd.4H * 1}, [Xn|SP]
	2, MatRegList, 1, byte(WORD), MatRefBase, 0x1b, 0xe1,
	// ld1 {Vd.4S * 1}, [Xn|SP]
	// ld1 {Vd.2S * 1}, [Xn|SP]
	2, MatRegList, 1, byte(DWORD), MatRefBase, 0x1b, 0xe9,
	// ld1 {Vd.2D * 1}, [Xn|SP]
	// ld1 {Vd.1D * 1}, [Xn|SP]
	2, MatRegList, 1, byte(QWORD), MatRefBase, 0x1b, 0xf1,
	// ld1 {Vd.16B * 2}, [Xn|SP]
	// ld1 {Vd.8B * 2}, [Xn|SP]
	2, MatRegList, 2, byte(BYTE), MatRefBase, 0x1b, 0xf9,
	// ld1 {Vd.8H * 2}, [Xn|SP]
	// ld1 {Vd.4H * 2}, [Xn|SP]
	2, MatRegList, 2, byte(WORD), MatRefBase, 0x1c, 0x1,
	// ld1 {Vd.4S * 2}, [Xn|SP]
	// ld1 {Vd.2S * 2}, [Xn|SP]
	2, MatRegList, 2, byte(DWORD), MatRefBase, 0x1c, 0x9,
	// ld1 {Vd.2D * 2}, [Xn|SP]
	// ld1 {Vd.1D * 2}, [Xn|SP]
	2, MatRegList, 2, byte(QWORD), MatRefBase, 0x1c, 0x11,
	// ld1 {Vd.16B * 3}, [Xn|SP]
	// ld1 {Vd.8B * 3}, [Xn|SP]
	2, MatRegList, 3, byte(BYTE), MatRefBase, 0x1c, 0x19,
	// ld1 {Vd.8H * 3}, [Xn|SP]
	// ld1 {Vd.4H * 3}, [Xn|SP]
	2, MatRegList, 3, byte(WORD), MatRefBase, 0x1c, 0x21,
	// ld1 {Vd.4S * 3}, [Xn|SP]
	// ld1 {Vd.2S * 3}, [Xn|SP]
	2, MatRegList, 3, byte(DWORD), MatRefBase, 0x1c, 0x29,
	// ld1 {Vd.2D * 3}, [Xn|SP]
	// ld1 {Vd.1D * 3}, [Xn|SP]
	2, MatRegList, 3, byte(QWORD), MatRefBase, 0x1c, 0x31,
	// ld1 {Vd.16B * 4}, [Xn|SP]
	// ld1 {Vd.8B * 4}, [Xn|SP]
	2, MatRegList, 4, byte(BYTE), MatRefBase, 0x1c, 0x39,
	// ld1 {Vd.8H * 4}, [Xn|SP]
	// ld1 {Vd.4H * 4}, [Xn|SP]
	2, MatRegList, 4, byte(WORD), MatRefBase, 0x1c, 0x41,
	// ld1 {Vd.4S * 4}, [Xn|SP]
	// ld1 {Vd.2S * 4}, [Xn|SP]
	2, MatRegList, 4, byte(DWORD), MatRefBase, 0x1c, 0x49,
	// ld1 {Vd.2D * 4}, [Xn|SP]
	// ld1 {Vd.1D * 4}, [Xn|SP]
	2, MatRegList, 4, byte(QWORD), MatRefBase, 0x1c, 0x51,
	// ld1 {Vd.8B * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(BYTE), 8, MatRefBase, MatLitInt, 8, 0x1c, 0x59,
	// ld1 {Vd.4H * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(WORD), 4, MatRefBase, MatLitInt, 8, 0x1c, 0x60,
	// ld1 {Vd.2S * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(DWORD), 2, MatRefBase, MatLitInt, 8, 0x1c, 0x67,
	// ld1 {Vd.1D * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(QWORD), 1, MatRefBase, MatLitInt, 8, 0x1c, 0x6e,
	// ld1 {Vd.16B * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(BYTE), 16, MatRefBase, MatLitInt, 16, 0x1c, 0x75,
	// ld1 {Vd.8H * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(WORD), 8, MatRefBase, MatLitInt, 16, 0x1c, 0x7c,
	// ld1 {Vd.4S * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(DWORD), 4, MatRefBase, MatLitInt, 16, 0x1c, 0x83,
	// ld1 {Vd.2D * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(QWORD), 2, MatRefBase, MatLitInt, 16, 0x1c, 0x8a,
	// ld1 {Vd.16B * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1 {Vd.8B * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(BYTE), MatRefBase, MatX, 0x1c, 0x91,
	// ld1 {Vd.8H * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.4H * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(WORD), MatRefBase, MatX, 0x1c, 0x9a,
	// ld1 {Vd.4S * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.2S * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(DWORD), MatRefBase, MatX, 0x1c, 0xa3,
	// ld1 {Vd.2D * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.1D * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(QWORD), MatRefBase, MatX, 0x1c, 0xac,
	// ld1 {Vd.8B * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(BYTE), 8, MatRefBase, MatLitInt, 16, 0x1c, 0xb5,
	// ld1 {Vd.4H * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(WORD), 4, MatRefBase, MatLitInt, 16, 0x1c, 0xbc,
	// ld1 {Vd.2S * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(DWORD), 2, MatRefBase, MatLitInt, 16, 0x1c, 0xc3,
	// ld1 {Vd.1D * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(QWORD), 1, MatRefBase, MatLitInt, 16, 0x1c, 0xca,
	// ld1 {Vd.16B * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(BYTE), 16, MatRefBase, MatLitInt, 32, 0x1c, 0xd1,
	// ld1 {Vd.8H * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(WORD), 8, MatRefBase, MatLitInt, 32, 0x1c, 0xd8,
	// ld1 {Vd.4S * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(DWORD), 4, MatRefBase, MatLitInt, 32, 0x1c, 0xdf,
	// ld1 {Vd.2D * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, MatLitInt, 32, 0x1c, 0xe6,
	// ld1 {Vd.16B * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1 {Vd.8B * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(BYTE), MatRefBase, MatX, 0x1c, 0xed,
	// ld1 {Vd.8H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.4H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(WORD), MatRefBase, MatX, 0x1c, 0xf6,
	// ld1 {Vd.4S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.2S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(DWORD), MatRefBase, MatX, 0x1c, 0xff,
	// ld1 {Vd.2D * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.1D * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(QWORD), MatRefBase, MatX, 0x1d, 0x8,
	// ld1 {Vd.8B * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(BYTE), 8, MatRefBase, MatLitInt, 24, 0x1d, 0x11,
	// ld1 {Vd.4H * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(WORD), 4, MatRefBase, MatLitInt, 24, 0x1d, 0x18,
	// ld1 {Vd.2S * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(DWORD), 2, MatRefBase, MatLitInt, 24, 0x1d, 0x1f,
	// ld1 {Vd.1D * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(QWORD), 1, MatRefBase, MatLitInt, 24, 0x1d, 0x26,
	// ld1 {Vd.16B * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(BYTE), 16, MatRefBase, MatLitInt, 48, 0x1d, 0x2d,
	// ld1 {Vd.8H * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(WORD), 8, MatRefBase, MatLitInt, 48, 0x1d, 0x34,
	// ld1 {Vd.4S * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(DWORD), 4, MatRefBase, MatLitInt, 48, 0x1d, 0x3b,
	// ld1 {Vd.2D * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, MatLitInt, 48, 0x1d, 0x42,
	// ld1 {Vd.16B * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1 {Vd.8B * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(BYTE), MatRefBase, MatX, 0x1d, 0x49,
	// ld1 {Vd.8H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.4H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(WORD), MatRefBase, MatX, 0x1d, 0x52,
	// ld1 {Vd.4S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.2S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(DWORD), MatRefBase, MatX, 0x1d, 0x5b,
	// ld1 {Vd.2D * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.1D * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(QWORD), MatRefBase, MatX, 0x1d, 0x64,
	// ld1 {Vd.8B * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(BYTE), 8, MatRefBase, MatLitInt, 32, 0x1d, 0x6d,
	// ld1 {Vd.4H * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(WORD), 4, MatRefBase, MatLitInt, 32, 0x1d, 0x74,
	// ld1 {Vd.2S * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(DWORD), 2, MatRefBase, MatLitInt, 32, 0x1d, 0x7b,
	// ld1 {Vd.1D * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(QWORD), 1, MatRefBase, MatLitInt, 32, 0x1d, 0x82,
	// ld1 {Vd.16B * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(BYTE), 16, MatRefBase, MatLitInt, 64, 0x1d, 0x89,
	// ld1 {Vd.8H * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(WORD), 8, MatRefBase, MatLitInt, 64, 0x1d, 0x90,
	// ld1 {Vd.4S * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(DWORD), 4, MatRefBase, MatLitInt, 64, 0x1d, 0x97,
	// ld1 {Vd.2D * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, MatLitInt, 64, 0x1d, 0x9e,
	// ld1 {Vd.16B * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1 {Vd.8B * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(BYTE), MatRefBase, MatX, 0x1d, 0xa5,
	// ld1 {Vd.8H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.4H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(WORD), MatRefBase, MatX, 0x1d, 0xae,
	// ld1 {Vd.4S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.2S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(DWORD), MatRefBase, MatX, 0x1d, 0xb7,
	// ld1 {Vd.2D * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld1 {Vd.1D * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(QWORD), MatRefBase, MatX, 0x1d, 0xc0,
	// ld1 {Vd.B * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(BYTE), MatRefBase, 0x1d, 0xc9,
	// ld1 {Vd.H * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(WORD), MatRefBase, 0x1d, 0xd2,
	// ld1 {Vd.S * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(DWORD), MatRefBase, 0x1d, 0xdb,
	// ld1 {Vd.D * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(QWORD), MatRefBase, 0x1d, 0xe4,
	// ld1 {Vd.B * 1}[i], [Xn|SP], #1
	3, MatRegListElement, 1, byte(BYTE), MatRefBase, MatLitInt, 1, 0x1d, 0xed,
	// ld1 {Vd.B * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(BYTE), MatRefBase, MatX, 0x1d, 0xf6,
	// ld1 {Vd.H * 1}[i], [Xn|SP], #2
	3, MatRegListElement, 1, byte(WORD), MatRefBase, MatLitInt, 2, 0x1e, 0x0,
	// ld1 {Vd.H * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(WORD), MatRefBase, MatX, 0x1e, 0x9,
	// ld1 {Vd.S * 1}[i], [Xn|SP], #4
	3, MatRegListElement, 1, byte(DWORD), MatRefBase, MatLitInt, 4, 0x1e, 0x13,
	// ld1 {Vd.S * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(DWORD), MatRefBase, MatX, 0x1e, 0x1c,
	// ld1 {Vd.D * 1}[i], [Xn|SP], #8
	3, MatRegListElement, 1, byte(QWORD), MatRefBase, MatLitInt, 8, 0x1e, 0x26,
	// ld1 {Vd.D * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(QWORD), MatRefBase, MatX, 0x1e, 0x2f,

	12,
	// ld1r {Vd.16B * 1}, [Xn|SP]
	// ld1r {Vd.8B * 1}, [Xn|SP]
	2, MatRegList, 1, byte(BYTE), MatRefBase, 0x1e, 0x39,
	// ld1r {Vd.8H * 1}, [Xn|SP]
	// ld1r {Vd.4H * 1}, [Xn|SP]
	2, MatRegList, 1, byte(WORD), MatRefBase, 0x1e, 0x41,
	// ld1r {Vd.4S * 1}, [Xn|SP]
	// ld1r {Vd.2S * 1}, [Xn|SP]
	2, MatRegList, 1, byte(DWORD), MatRefBase, 0x1e, 0x49,
	// ld1r {Vd.2D * 1}, [Xn|SP]
	// ld1r {Vd.1D * 1}, [Xn|SP]
	2, MatRegList, 1, byte(QWORD), MatRefBase, 0x1e, 0x51,
	// ld1r {Vd.16B * 1}, [Xn|SP], #1
	// ld1r {Vd.8B * 1}, [Xn|SP], #1
	3, MatRegList, 1, byte(BYTE), MatRefBase, MatLitInt, 1, 0x1e, 0x59,
	// ld1r {Vd.8H * 1}, [Xn|SP], #2
	// ld1r {Vd.4H * 1}, [Xn|SP], #2
	3, MatRegList, 1, byte(WORD), MatRefBase, MatLitInt, 2, 0x1e, 0x61,
	// ld1r {Vd.4S * 1}, [Xn|SP], #4
	// ld1r {Vd.2S * 1}, [Xn|SP], #4
	3, MatRegList, 1, byte(DWORD), MatRefBase, MatLitInt, 4, 0x1e, 0x69,
	// ld1r {Vd.2D * 1}, [Xn|SP], #8
	// ld1r {Vd.1D * 1}, [Xn|SP], #8
	3, MatRegList, 1, byte(QWORD), MatRefBase, MatLitInt, 8, 0x1e, 0x71,
	// ld1r {Vd.16B * 1}, [Xn|SP], Xm  ·····················································  (m != 31)
	// ld1r {Vd.8B * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 1, byte(BYTE), MatRefBase, MatX, 0x1e, 0x79,
	// ld1r {Vd.8H * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1r {Vd.4H * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 1, byte(WORD), MatRefBase, MatX, 0x1e, 0x82,
	// ld1r {Vd.4S * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1r {Vd.2S * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 1, byte(DWORD), MatRefBase, MatX, 0x1e, 0x8b,
	// ld1r {Vd.2D * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld1r {Vd.1D * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 1, byte(QWORD), MatRefBase, MatX, 0x1e, 0x94,

	27,
	// ld2 {Vd.16B * 2}, [Xn|SP]
	// ld2 {Vd.8B * 2}, [Xn|SP]
	2, MatRegList, 2, byte(BYTE), MatRefBase, 0x1e, 0x9d,
	// ld2 {Vd.8H * 2}, [Xn|SP]
	// ld2 {Vd.4H * 2}, [Xn|SP]
	2, MatRegList, 2, byte(WORD), MatRefBase, 0x1e, 0xa5,
	// ld2 {Vd.4S * 2}, [Xn|SP]
	// ld2 {Vd.2S * 2}, [Xn|SP]
	2, MatRegList, 2, byte(DWORD), MatRefBase, 0x1e, 0xad,
	// ld2 {Vd.2D * 2}, [Xn|SP]
	2, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, 0x1e, 0xb5,
	// ld2 {Vd.8B * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(BYTE), 8, MatRefBase, MatLitInt, 16, 0x1e, 0xbd,
	// ld2 {Vd.4H * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(WORD), 4, MatRefBase, MatLitInt, 16, 0x1e, 0xc4,
	// ld2 {Vd.2S * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(DWORD), 2, MatRefBase, MatLitInt, 16, 0x1e, 0xcb,
	// ld2 {Vd.16B * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(BYTE), 16, MatRefBase, MatLitInt, 32, 0x1e, 0xd2,
	// ld2 {Vd.8H * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(WORD), 8, MatRefBase, MatLitInt, 32, 0x1e, 0xd9,
	// ld2 {Vd.4S * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(DWORD), 4, MatRefBase, MatLitInt, 32, 0x1e, 0xe0,
	// ld2 {Vd.2D * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, MatLitInt, 32, 0x1e, 0xe7,
	// ld2 {Vd.16B * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld2 {Vd.8B * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(BYTE), MatRefBase, MatX, 0x1e, 0xee,
	// ld2 {Vd.8H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld2 {Vd.4H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(WORD), MatRefBase, MatX, 0x1e, 0xf7,
	// ld2 {Vd.4S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld2 {Vd.2S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(DWORD), MatRefBase, MatX, 0x1f, 0x0,
	// ld2 {Vd.2D * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, MatX, 0x1f, 0x9,
	// ld2 {Vd.B * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(BYTE), MatRefBase, 0x1f, 0x12,
	// ld2 {Vd.H * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(WORD), MatRefBase, 0x1f, 0x1b,
	// ld2 {Vd.S * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(DWORD), MatRefBase, 0x1f, 0x24,
	// ld2 {Vd.D * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(QWORD), MatRefBase, 0x1f, 0x2d,
	// ld2 {Vd.B * 2}[i], [Xn|SP], #2
	3, MatRegListElement, 2, byte(BYTE), MatRefBase, MatLitInt, 2, 0x1f, 0x36,
	// ld2 {Vd.B * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(BYTE), MatRefBase, MatX, 0x1f, 0x3f,
	// ld2 {Vd.H * 2}[i], [Xn|SP], #4
	3, MatRegListElement, 2, byte(WORD), MatRefBase, MatLitInt, 4, 0x1f, 0x49,
	// ld2 {Vd.H * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(WORD), MatRefBase, MatX, 0x1f, 0x52,
	// ld2 {Vd.S * 2}[i], [Xn|SP], #8
	3, MatRegListElement, 2, byte(DWORD), MatRefBase, MatLitInt, 8, 0x1f, 0x5c,
	// ld2 {Vd.S * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(DWORD), MatRefBase, MatX, 0x1f, 0x65,
	// ld2 {Vd.D * 2}[i], [Xn|SP], #16
	3, MatRegListElement, 2, byte(QWORD), MatRefBase, MatLitInt, 16, 0x1f, 0x6f,
	// ld2 {Vd.D * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(QWORD), MatRefBase, MatX, 0x1f, 0x78,

	12,
	// ld2r {Vd.16B * 2}, [Xn|SP]
	// ld2r {Vd.8B * 2}, [Xn|SP]
	2, MatRegList, 2, byte(BYTE), MatRefBase, 0x1f, 0x82,
	// ld2r {Vd.8H * 2}, [Xn|SP]
	// ld2r {Vd.4H * 2}, [Xn|SP]
	2, MatRegList, 2, byte(WORD), MatRefBase, 0x1f, 0x8a,
	// ld2r {Vd.4S * 2}, [Xn|SP]
	// ld2r {Vd.2S * 2}, [Xn|SP]
	2, MatRegList, 2, byte(DWORD), MatRefBase, 0x1f, 0x92,
	// ld2r {Vd.2D * 2}, [Xn|SP]
	// ld2r {Vd.1D * 2}, [Xn|SP]
	2, MatRegList, 2, byte(QWORD), MatRefBase, 0x1f, 0x9a,
	// ld2r {Vd.16B * 2}, [Xn|SP], #2
	// ld2r {Vd.8B * 2}, [Xn|SP], #2
	3, MatRegList, 2, byte(BYTE), MatRefBase, MatLitInt, 2, 0x1f, 0xa2,
	// ld2r {Vd.8H * 2}, [Xn|SP], #4
	// ld2r {Vd.4H * 2}, [Xn|SP], #4
	3, MatRegList, 2, byte(WORD), MatRefBase, MatLitInt, 4, 0x1f, 0xaa,
	// ld2r {Vd.4S * 2}, [Xn|SP], #8
	// ld2r {Vd.2S * 2}, [Xn|SP], #8
	3, MatRegList, 2, byte(DWORD), MatRefBase, MatLitInt, 8, 0x1f, 0xb2,
	// ld2r {Vd.2D * 2}, [Xn|SP], #16
	// ld2r {Vd.1D * 2}, [Xn|SP], #16
	3, MatRegList, 2, byte(QWORD), MatRefBase, MatLitInt, 16, 0x1f, 0xba,
	// ld2r {Vd.16B * 2}, [Xn|SP], Xm  ·····················································  (m != 31)
	// ld2r {Vd.8B * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 2, byte(BYTE), MatRefBase, MatX, 0x1f, 0xc2,
	// ld2r {Vd.8H * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld2r {Vd.4H * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 2, byte(WORD), MatRefBase, MatX, 0x1f, 0xcb,
	// ld2r {Vd.4S * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld2r {Vd.2S * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 2, byte(DWORD), MatRefBase, MatX, 0x1f, 0xd4,
	// ld2r {Vd.2D * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld2r {Vd.1D * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 2, byte(QWORD), MatRefBase, MatX, 0x1f, 0xdd,

	27,
	// ld3 {Vd.16B * 3}, [Xn|SP]
	// ld3 {Vd.8B * 3}, [Xn|SP]
	2, MatRegList, 3, byte(BYTE), MatRefBase, 0x1f, 0xe6,
	// ld3 {Vd.8H * 3}, [Xn|SP]
	// ld3 {Vd.4H * 3}, [Xn|SP]
	2, MatRegList, 3, byte(WORD), MatRefBase, 0x1f, 0xee,
	// ld3 {Vd.4S * 3}, [Xn|SP]
	// ld3 {Vd.2S * 3}, [Xn|SP]
	2, MatRegList, 3, byte(DWORD), MatRefBase, 0x1f, 0xf6,
	// ld3 {Vd.2D * 3}, [Xn|SP]
	2, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, 0x1f, 0xfe,
	// ld3 {Vd.8B * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(BYTE), 8, MatRefBase, MatLitInt, 24, 0x20, 0x6,
	// ld3 {Vd.4H * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(WORD), 4, MatRefBase, MatLitInt, 24, 0x20, 0xd,
	// ld3 {Vd.2S * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(DWORD), 2, MatRefBase, MatLitInt, 24, 0x20, 0x14,
	// ld3 {Vd.16B * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(BYTE), 16, MatRefBase, MatLitInt, 48, 0x20, 0x1b,
	// ld3 {Vd.8H * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(WORD), 8, MatRefBase, MatLitInt, 48, 0x20, 0x22,
	// ld3 {Vd.4S * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(DWORD), 4, MatRefBase, MatLitInt, 48, 0x20, 0x29,
	// ld3 {Vd.2D * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, MatLitInt, 48, 0x20, 0x30,
	// ld3 {Vd.16B * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld3 {Vd.8B * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(BYTE), MatRefBase, MatX, 0x20, 0x37,
	// ld3 {Vd.8H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld3 {Vd.4H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(WORD), MatRefBase, MatX, 0x20, 0x40,
	// ld3 {Vd.4S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld3 {Vd.2S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(DWORD), MatRefBase, MatX, 0x20, 0x49,
	// ld3 {Vd.2D * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, MatX, 0x20, 0x52,
	// ld3 {Vd.B * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(BYTE), MatRefBase, 0x20, 0x5b,
	// ld3 {Vd.H * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(WORD), MatRefBase, 0x20, 0x64,
	// ld3 {Vd.S * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(DWORD), MatRefBase, 0x20, 0x6d,
	// ld3 {Vd.D * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(QWORD), MatRefBase, 0x20, 0x76,
	// ld3 {Vd.B * 3}[i], [Xn|SP], #3
	3, MatRegListElement, 3, byte(BYTE), MatRefBase, MatLitInt, 3, 0x20, 0x7f,
	// ld3 {Vd.B * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(BYTE), MatRefBase, MatX, 0x20, 0x88,
	// ld3 {Vd.H * 3}[i], [Xn|SP], #6
	3, MatRegListElement, 3, byte(WORD), MatRefBase, MatLitInt, 6, 0x20, 0x92,
	// ld3 {Vd.H * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(WORD), MatRefBase, MatX, 0x20, 0x9b,
	// ld3 {Vd.S * 3}[i], [Xn|SP], #12
	3, MatRegListElement, 3, byte(DWORD), MatRefBase, MatLitInt, 12, 0x20, 0xa5,
	// ld3 {Vd.S * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(DWORD), MatRefBase, MatX, 0x20, 0xae,
	// ld3 {Vd.D * 3}[i], [Xn|SP], #24
	3, MatRegListElement, 3, byte(QWORD), MatRefBase, MatLitInt, 24, 0x20, 0xb8,
	// ld3 {Vd.D * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(QWORD), MatRefBase, MatX, 0x20, 0xc1,

	12,
	// ld3r {Vd.16B * 3}, [Xn|SP]
	// ld3r {Vd.8B * 3}, [Xn|SP]
	2, MatRegList, 3, byte(BYTE), MatRefBase, 0x20, 0xcb,
	// ld3r {Vd.8H * 3}, [Xn|SP]
	// ld3r {Vd.4H * 3}, [Xn|SP]
	2, MatRegList, 3, byte(WORD), MatRefBase, 0x20, 0xd3,
	// ld3r {Vd.4S * 3}, [Xn|SP]
	// ld3r {Vd.2S * 3}, [Xn|SP]
	2, MatRegList, 3, byte(DWORD), MatRefBase, 0x20, 0xdb,
	// ld3r {Vd.2D * 3}, [Xn|SP]
	// ld3r {Vd.1D * 3}, [Xn|SP]
	2, MatRegList, 3, byte(QWORD), MatRefBase, 0x20, 0xe3,
	// ld3r {Vd.16B * 3}, [Xn|SP], #3
	// ld3r {Vd.8B * 3}, [Xn|SP], #3
	3, MatRegList, 3, byte(BYTE), MatRefBase, MatLitInt, 3, 0x20, 0xeb,
	// ld3r {Vd.8H * 3}, [Xn|SP], #6
	// ld3r {Vd.4H * 3}, [Xn|SP], #6
	3, MatRegList, 3, byte(WORD), MatRefBase, MatLitInt, 6, 0x20, 0xf3,
	// ld3r {Vd.4S * 3}, [Xn|SP], #12
	// ld3r {Vd.2S * 3}, [Xn|SP], #12
	3, MatRegList, 3, byte(DWORD), MatRefBase, MatLitInt, 12, 0x20, 0xfb,
	// ld3r {Vd.2D * 3}, [Xn|SP], #24
	// ld3r {Vd.1D * 3}, [Xn|SP], #24
	3, MatRegList, 3, byte(QWORD), MatRefBase, MatLitInt, 24, 0x21, 0x3,
	// ld3r {Vd.16B * 3}, [Xn|SP], Xm  ·····················································  (m != 31)
	// ld3r {Vd.8B * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 3, byte(BYTE), MatRefBase, MatX, 0x21, 0xb,
	// ld3r {Vd.8H * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld3r {Vd.4H * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 3, byte(WORD), MatRefBase, MatX, 0x21, 0x14,
	// ld3r {Vd.4S * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld3r {Vd.2S * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 3, byte(DWORD), MatRefBase, MatX, 0x21, 0x1d,
	// ld3r {Vd.2D * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld3r {Vd.1D * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 3, byte(QWORD), MatRefBase, MatX, 0x21, 0x26,

	27,
	// ld4 {Vd.16B * 4}, [Xn|SP]
	// ld4 {Vd.8B * 4}, [Xn|SP]
	2, MatRegList, 4, byte(BYTE), MatRefBase, 0x21, 0x2f,
	// ld4 {Vd.8H * 4}, [Xn|SP]
	// ld4 {Vd.4H * 4}, [Xn|SP]
	2, MatRegList, 4, byte(WORD), MatRefBase, 0x21, 0x37,
	// ld4 {Vd.4S * 4}, [Xn|SP]
	// ld4 {Vd.2S * 4}, [Xn|SP]
	2, MatRegList, 4, byte(DWORD), MatRefBase, 0x21, 0x3f,
	// ld4 {Vd.2D * 4}, [Xn|SP]
	2, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, 0x21, 0x47,
	// ld4 {Vd.8B * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(BYTE), 8, MatRefBase, MatLitInt, 32, 0x21, 0x4f,
	// ld4 {Vd.4H * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(WORD), 4, MatRefBase, MatLitInt, 32, 0x21, 0x56,
	// ld4 {Vd.2S * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(DWORD), 2, MatRefBase, MatLitInt, 32, 0x21, 0x5d,
	// ld4 {Vd.16B * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(BYTE), 16, MatRefBase, MatLitInt, 64, 0x21, 0x64,
	// ld4 {Vd.8H * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(WORD), 8, MatRefBase, MatLitInt, 64, 0x21, 0x6b,
	// ld4 {Vd.4S * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(DWORD), 4, MatRefBase, MatLitInt, 64, 0x21, 0x72,
	// ld4 {Vd.2D * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, MatLitInt, 64, 0x21, 0x79,
	// ld4 {Vd.16B * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld4 {Vd.8B * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(BYTE), MatRefBase, MatX, 0x21, 0x80,
	// ld4 {Vd.8H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld4 {Vd.4H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(WORD), MatRefBase, MatX, 0x21, 0x89,
	// ld4 {Vd.4S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// ld4 {Vd.2S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(DWORD), MatRefBase, MatX, 0x21, 0x92,
	// ld4 {Vd.2D * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, MatX, 0x21, 0x9b,
	// ld4 {Vd.B * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(BYTE), MatRefBase, 0x21, 0xa4,
	// ld4 {Vd.H * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(WORD), MatRefBase, 0x21, 0xad,
	// ld4 {Vd.S * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(DWORD), MatRefBase, 0x21, 0xb6,
	// ld4 {Vd.D * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(QWORD), MatRefBase, 0x21, 0xbf,
	// ld4 {Vd.B * 4}[i], [Xn|SP], #4
	3, MatRegListElement, 4, byte(BYTE), MatRefBase, MatLitInt, 4, 0x21, 0xc8,
	// ld4 {Vd.B * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(BYTE), MatRefBase, MatX, 0x21, 0xd1,
	// ld4 {Vd.H * 4}[i], [Xn|SP], #8
	3, MatRegListElement, 4, byte(WORD), MatRefBase, MatLitInt, 8, 0x21, 0xdb,
	// ld4 {Vd.H * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(WORD), MatRefBase, MatX, 0x21, 0xe4,
	// ld4 {Vd.S * 4}[i], [Xn|SP], #16
	3, MatRegListElement, 4, byte(DWORD), MatRefBase, MatLitInt, 16, 0x21, 0xee,
	// ld4 {Vd.S * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(DWORD), MatRefBase, MatX, 0x21, 0xf7,
	// ld4 {Vd.D * 4}[i], [Xn|SP], #32
	3, MatRegListElement, 4, byte(QWORD), MatRefBase, MatLitInt, 32, 0x22, 0x1,
	// ld4 {Vd.D * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(QWORD), MatRefBase, MatX, 0x22, 0xa,

	12,
	// ld4r {Vd.16B * 4}, [Xn|SP]
	// ld4r {Vd.8B * 4}, [Xn|SP]
	2, MatRegList, 4, byte(BYTE), MatRefBase, 0x22, 0x14,
	// ld4r {Vd.8H * 4}, [Xn|SP]
	// ld4r {Vd.4H * 4}, [Xn|SP]
	2, MatRegList, 4, byte(WORD), MatRefBase, 0x22, 0x1c,
	// ld4r {Vd.4S * 4}, [Xn|SP]
	// ld4r {Vd.2S * 4}, [Xn|SP]
	2, MatRegList, 4, byte(DWORD), MatRefBase, 0x22, 0x24,
	// ld4r {Vd.2D * 4}, [Xn|SP]
	// ld4r {Vd.1D * 4}, [Xn|SP]
	2, MatRegList, 4, byte(QWORD), MatRefBase, 0x22, 0x2c,
	// ld4r {Vd.16B * 4}, [Xn|SP], #4
	// ld4r {Vd.8B * 4}, [Xn|SP], #4
	3, MatRegList, 4, byte(BYTE), MatRefBase, MatLitInt, 4, 0x22, 0x34,
	// ld4r {Vd.8H * 4}, [Xn|SP], #8
	// ld4r {Vd.4H * 4}, [Xn|SP], #8
	3, MatRegList, 4, byte(WORD), MatRefBase, MatLitInt, 8, 0x22, 0x3c,
	// ld4r {Vd.4S * 4}, [Xn|SP], #16
	// ld4r {Vd.2S * 4}, [Xn|SP], #16
	3, MatRegList, 4, byte(DWORD), MatRefBase, MatLitInt, 16, 0x22, 0x44,
	// ld4r {Vd.2D * 4}, [Xn|SP], #32
	// ld4r {Vd.1D * 4}, [Xn|SP], #32
	3, MatRegList, 4, byte(QWORD), MatRefBase, MatLitInt, 32, 0x22, 0x4c,
	// ld4r {Vd.16B * 4}, [Xn|SP], Xm  ·····················································  (m != 31)
	// ld4r {Vd.8B * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 4, byte(BYTE), MatRefBase, MatX, 0x22, 0x54,
	// ld4r {Vd.8H * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld4r {Vd.4H * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 4, byte(WORD), MatRefBase, MatX, 0x22, 0x5d,
	// ld4r {Vd.4S * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld4r {Vd.2S * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 4, byte(DWORD), MatRefBase, MatX, 0x22, 0x66,
	// ld4r {Vd.2D * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// ld4r {Vd.1D * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	3, MatRegList, 4, byte(QWORD), MatRefBase, MatX, 0x22, 0x6f,

	2,
	// ldadd Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0x78,
	// ldadd Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x22, 0x80,

	2,
	// ldadda Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0x88,
	// ldadda Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x22, 0x90,

	1,
	// ldaddab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0x98,

	1,
	// ldaddah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xa0,

	2,
	// ldaddal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xa8,
	// ldaddal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x22, 0xb0,

	1,
	// ldaddalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xb8,

	1,
	// ldaddalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xc0,

	1,
	// ldaddb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xc8,

	1,
	// ldaddh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xd0,

	2,
	// ldaddl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xd8,
	// ldaddl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x22, 0xe0,

	1,
	// ldaddlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xe8,

	1,
	// ldaddlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x22, 0xf0,

	2,
	// ldapr Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x22, 0xf8,
	// ldapr Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x22, 0xff,

	1,
	// ldaprb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x6,

	1,
	// ldaprh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0xd,

	2,
	// ldapur Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x23, 0x14,
	// ldapur Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x23, 0x1c,

	1,
	// ldapurb Wd, [Xn|SP {, #imm }]  ············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x23, 0x24,

	1,
	// ldapurh Wd, [Xn|SP {, #imm }]  ············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x23, 0x2c,

	2,
	// ldapursb Wd, [Xn|SP {, #imm }]  ···········································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x23, 0x34,
	// ldapursb Xd, [Xn|SP {, #imm }]  ···········································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x23, 0x3c,

	2,
	// ldapursh Wd, [Xn|SP {, #imm }]  ···········································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x23, 0x44,
	// ldapursh Xd, [Xn|SP {, #imm }]  ···········································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x23, 0x4c,

	1,
	// ldapursw Xd, [Xn|SP {, #imm }]  ···········································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x23, 0x54,

	2,
	// ldar Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x5c,
	// ldar Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x23, 0x63,

	1,
	// ldarb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x6a,

	1,
	// ldarh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x71,

	2,
	// ldaxp Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0x78,
	// ldaxp Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x23, 0x80,

	2,
	// ldaxr Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x88,
	// ldaxr Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x23, 0x8f,

	1,
	// ldaxrb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x96,

	1,
	// ldaxrh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x23, 0x9d,

	2,
	// ldclr Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xa4,
	// ldclr Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x23, 0xac,

	2,
	// ldclra Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xb4,
	// ldclra Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x23, 0xbc,

	1,
	// ldclrab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xc4,

	1,
	// ldclrah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xcc,

	2,
	// ldclral Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xd4,
	// ldclral Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x23, 0xdc,

	1,
	// ldclralb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xe4,

	1,
	// ldclralh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xec,

	1,
	// ldclrb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xf4,

	1,
	// ldclrh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x23, 0xfc,

	2,
	// ldclrl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x4,
	// ldclrl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x24, 0xc,

	1,
	// ldclrlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x14,

	1,
	// ldclrlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x1c,

	2,
	// ldeor Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x24,
	// ldeor Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x24, 0x2c,

	2,
	// ldeora Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x34,
	// ldeora Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x24, 0x3c,

	1,
	// ldeorab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x44,

	1,
	// ldeorah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x4c,

	2,
	// ldeoral Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x54,
	// ldeoral Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x24, 0x5c,

	1,
	// ldeoralb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x64,

	1,
	// ldeoralh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x6c,

	1,
	// ldeorb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x74,

	1,
	// ldeorh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x7c,

	2,
	// ldeorl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x84,
	// ldeorl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x24, 0x8c,

	1,
	// ldeorlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x94,

	1,
	// ldeorlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x24, 0x9c,

	2,
	// ldlar Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x24, 0xa4,
	// ldlar Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x24, 0xab,

	1,
	// ldlarb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x24, 0xb2,

	1,
	// ldlarh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x24, 0xb9,

	5,
	// ldnp Sd, Sn, [Xm|SP {, #imm }]  ·································  (-256 <= imm < 256, imm >> 2)
	3, MatS, MatS, MatRefOffset, 0x24, 0xc0,
	// ldnp Dd, Dn, [Xm|SP {, #imm }]  ·································  (-512 <= imm < 512, imm >> 3)
	3, MatD, MatD, MatRefOffset, 0x24, 0xca,
	// ldnp Qd, Qn, [Xm|SP {, #imm }]  ·······························  (-1024 <= imm < 1024, imm >> 4)
	3, MatQ, MatQ, MatRefOffset, 0x24, 0xd4,
	// ldnp Wd, Wn, [Xm|SP {, #imm }]  ·································  (-256 <= imm < 256, imm >> 2)
	3, MatW, MatW, MatRefOffset, 0x24, 0xde,
	// ldnp Xd, Xn, [Xm|SP {, #imm }]  ·································  (-512 <= imm < 512, imm >> 3)
	3, MatX, MatX, MatRefOffset, 0x24, 0xe8,

	15,
	// ldp Sd, Sn, [Xm|SP], #imm  ······································  (-256 <= imm < 256, imm >> 2)
	4, MatS, MatS, MatRefBase, MatImm, 0x24, 0xf2,
	// ldp Dd, Dn, [Xm|SP], #imm  ······································  (-512 <= imm < 512, imm >> 3)
	4, MatD, MatD, MatRefBase, MatImm, 0x24, 0xfc,
	// ldp Qd, Qn, [Xm|SP], #imm  ····································  (-1024 <= imm < 1024, imm >> 4)
	4, MatQ, MatQ, MatRefBase, MatImm, 0x25, 0x6,
	// ldp Sd, Sn, [Xm|SP, #imm]!  ·····································  (-256 <= imm < 256, imm >> 2)
	3, MatS, MatS, MatRefPre, 0x25, 0x10,
	// ldp Dd, Dn, [Xm|SP, #imm]!  ·····································  (-512 <= imm < 512, imm >> 3)
	3, MatD, MatD, MatRefPre, 0x25, 0x1a,
	// ldp Qd, Qn, [Xm|SP, #imm]!  ···································  (-1024 <= imm < 1024, imm >> 4)
	3, MatQ, MatQ, MatRefPre, 0x25, 0x24,
	// ldp Sd, Sn, [Xm|SP {, #imm }]  ··································  (-256 <= imm < 256, imm >> 2)
	3, MatS, MatS, MatRefOffset, 0x25, 0x2e,
	// ldp Dd, Dn, [Xm|SP {, #imm }]  ··································  (-512 <= imm < 512, imm >> 3)
	3, MatD, MatD, MatRefOffset, 0x25, 0x38,
	// ldp Qd, Qn, [Xm|SP {, #imm }]  ································  (-1024 <= imm < 1024, imm >> 4)
	3, MatQ, MatQ, MatRefOffset, 0x25, 0x42,
	// ldp Wd, Wn, [Xm|SP], #imm  ······································  (-256 <= imm < 256, imm >> 2)
	4, MatW, MatW, MatRefBase, MatImm, 0x25, 0x4c,
	// ldp Xd, Xn, [Xm|SP], #imm  ······································  (-512 <= imm < 512, imm >> 3)
	4, MatX, MatX, MatRefBase, MatImm, 0x25, 0x56,
	// ldp Wd, Wn, [Xm|SP, #imm]!  ·····································  (-256 <= imm < 256, imm >> 2)
	3, MatW, MatW, MatRefPre, 0x25, 0x60,
	// ldp Xd, Xn, [Xm|SP, #imm]!  ·····································  (-512 <= imm < 512, imm >> 3)
	3, MatX, MatX, MatRefPre, 0x25, 0x6a,
	// ldp Wd, Wn, [Xm|SP {, #imm }]  ··································  (-256 <= imm < 256, imm >> 2)
	3, MatW, MatW, MatRefOffset, 0x25, 0x74,
	// ldp Xd, Xn, [Xm|SP {, #imm }]  ··································  (-512 <= imm < 512, imm >> 3)
	3, MatX, MatX, MatRefOffset, 0x25, 0x7e,

	3,
	// ldpsw Xd, Xn, [Xm|SP], #imm  ····································  (-256 <= imm < 256, imm >> 2)
	4, MatX, MatX, MatRefBase, MatImm, 0x25, 0x88,
	// ldpsw Xd, Xn, [Xm|SP, #imm]!  ···································  (-256 <= imm < 256, imm >> 2)
	3, MatX, MatX, MatRefPre, 0x25, 0x92,
	// ldpsw Xd, Xn, [Xm|SP {, #imm }]  ································  (-256 <= imm < 256, imm >> 2)
	3, MatX, MatX, MatRefOffset, 0x25, 0x9c,

	33,
	// ldr Bd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatB, MatRefBase, MatImm, 0x25, 0xa6,
	// ldr Hd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatH, MatRefBase, MatImm, 0x25, 0xae,
	// ldr Sd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatS, MatRefBase, MatImm, 0x25, 0xb6,
	// ldr Dd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatD, MatRefBase, MatImm, 0x25, 0xbe,
	// ldr Qd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatQ, MatRefBase, MatImm, 0x25, 0xc6,
	// ldr Bd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatB, MatRefPre, 0x25, 0xce,
	// ldr Hd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatH, MatRefPre, 0x25, 0xd6,
	// ldr Sd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatS, MatRefPre, 0x25, 0xde,
	// ldr Dd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatD, MatRefPre, 0x25, 0xe6,
	// ldr Qd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatQ, MatRefPre, 0x25, 0xee,
	// ldr Bd, [Xn|SP {, #imm }]  ··················································  (0 <= imm < 4096)
	2, MatB, MatRefOffset, 0x25, 0xf6,
	// ldr Hd, [Xn|SP {, #imm }]  ········································  (0 <= imm < 8192, imm >> 1)
	2, MatH, MatRefOffset, 0x26, 0x0,
	// ldr Sd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 16384, imm >> 2)
	2, MatS, MatRefOffset, 0x26, 0xb,
	// ldr Dd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 32768, imm >> 3)
	2, MatD, MatRefOffset, 0x26, 0x16,
	// ldr Qd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 65536, imm >> 4)
	2, MatQ, MatRefOffset, 0x26, 0x21,
	// ldr Wd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x26, 0x2c,
	// ldr Xd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatX, MatRefBase, MatImm, 0x26, 0x34,
	// ldr Wd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x26, 0x3c,
	// ldr Xd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatX, MatRefPre, 0x26, 0x44,
	// ldr Wd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 16384, imm >> 2)
	2, MatW, MatRefOffset, 0x26, 0x4c,
	// ldr Xd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 32768, imm >> 3)
	2, MatX, MatRefOffset, 0x26, 0x57,
	// ldr Sd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatS, MatOffset, 0x26, 0x62,
	// ldr Dd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatD, MatOffset, 0x26, 0x6a,
	// ldr Qd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatQ, MatOffset, 0x26, 0x72,
	// ldr Wd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatW, MatOffset, 0x26, 0x7a,
	// ldr Xd, <offset>  ··········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatX, MatOffset, 0x26, 0x82,
	// ldr Bd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ·······························  (imm == 0)
	2, MatB, MatRefIndex, 0x26, 0x8a,
	// ldr Hd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 1])
	2, MatH, MatRefIndex, 0x26, 0x96,
	// ldr Sd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 2])
	2, MatS, MatRefIndex, 0x26, 0xa2,
	// ldr Dd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 3])
	2, MatD, MatRefIndex, 0x26, 0xae,
	// ldr Qd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 4])
	2, MatQ, MatRefIndex, 0x26, 0xba,
	// ldr Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 2])
	2, MatW, MatRefIndex, 0x26, 0xc6,
	// ldr Xd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 3])
	2, MatX, MatRefIndex, 0x26, 0xd2,

	2,
	// ldraa Xd, [Xn|SP {, #imm }]  ··································  (-4096 <= imm < 4096, imm >> 3)
	2, MatX, MatRefOffset, 0x26, 0xde,
	// ldraa Xd, [Xn|SP, #imm]!  ·····································  (-4096 <= imm < 4096, imm >> 3)
	2, MatX, MatRefPre, 0x26, 0xef,

	2,
	// ldrab Xd, [Xn|SP {, #imm }]  ··································  (-4096 <= imm < 4096, imm >> 3)
	2, MatX, MatRefOffset, 0x27, 0x0,
	// ldrab Xd, [Xn|SP, #imm]!  ·····································  (-4096 <= imm < 4096, imm >> 3)
	2, MatX, MatRefPre, 0x27, 0x11,

	4,
	// ldrb Wd, [Xn|SP], #imm  ···················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x27, 0x22,
	// ldrb Wd, [Xn|SP, #imm]!  ··················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x27, 0x2a,
	// ldrb Wd, [Xn|SP {, #imm }]  ·················································  (0 <= imm < 4096)
	2, MatW, MatRefOffset, 0x27, 0x32,
	// ldrb Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ······························  (imm == 0)
	2, MatW, MatRefIndex, 0x27, 0x3c,

	4,
	// ldrh Wd, [Xn|SP], #imm  ···················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x27, 0x48,
	// ldrh Wd, [Xn|SP, #imm]!  ··················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x27, 0x50,
	// ldrh Wd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 8192, imm >> 1)
	2, MatW, MatRefOffset, 0x27, 0x58,
	// ldrh Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ·························  (imm in [0, 1])
	2, MatW, MatRefIndex, 0x27, 0x63,

	8,
	// ldrsb Wd, [Xn|SP], #imm  ··················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x27, 0x6f,
	// ldrsb Xd, [Xn|SP], #imm  ··················································  (-256 <= imm < 256)
	3, MatX, MatRefBase, MatImm, 0x27, 0x77,
	// ldrsb Wd, [Xn|SP, #imm]!  ·················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x27, 0x7f,
	// ldrsb Xd, [Xn|SP, #imm]!  ·················································  (-256 <= imm < 256)
	2, MatX, MatRefPre, 0x27, 0x87,
	// ldrsb Wd, [Xn|SP {, #imm }]  ················································  (0 <= imm < 4096)
	2, MatW, MatRefOffset, 0x27, 0x8f,
	// ldrsb Xd, [Xn|SP {, #imm }]  ················································  (0 <= imm < 4096)
	2, MatX, MatRefOffset, 0x27, 0x99,
	// ldrsb Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ·····························  (imm == 0)
	2, MatW, MatRefIndex, 0x27, 0xa3,
	// ldrsb Xd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ·····························  (imm == 0)
	2, MatX, MatRefIndex, 0x27, 0xaf,

	8,
	// ldrsh Wd, [Xn|SP], #imm  ··················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x27, 0xbb,
	// ldrsh Xd, [Xn|SP], #imm  ··················································  (-256 <= imm < 256)
	3, MatX, MatRefBase, MatImm, 0x27, 0xc3,
	// ldrsh Wd, [Xn|SP, #imm]!  ·················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x27, 0xcb,
	// ldrsh Xd, [Xn|SP, #imm]!  ·················································  (-256 <= imm < 256)
	2, MatX, MatRefPre, 0x27, 0xd3,
	// ldrsh Wd, [Xn|SP {, #imm }]  ······································  (0 <= imm < 8192, imm >> 1)
	2, MatW, MatRefOffset, 0x27, 0xdb,
	// ldrsh Xd, [Xn|SP {, #imm }]  ······································  (0 <= imm < 8192, imm >> 1)
	2, MatX, MatRefOffset, 0x27, 0xe6,
	// ldrsh Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ························  (imm in [0, 1])
	2, MatW, MatRefIndex, 0x27, 0xf1,
	// ldrsh Xd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ························  (imm in [0, 1])
	2, MatX, MatRefIndex, 0x27, 0xfd,

	5,
	// ldrsw Xd, [Xn|SP], #imm  ··················································  (-256 <= imm < 256)
	3, MatX, MatRefBase, MatImm, 0x28, 0x9,
	// ldrsw Xd, [Xn|SP, #imm]!  ·················································  (-256 <= imm < 256)
	2, MatX, MatRefPre, 0x28, 0x11,
	// ldrsw Xd, [Xn|SP {, #imm }]  ·····································  (0 <= imm < 16384, imm >> 2)
	2, MatX, MatRefOffset, 0x28, 0x19,
	// ldrsw Xd, <offset>  ········································  (offset >> 2 is 19-bit (+/- 1 MB))
	2, MatX, MatOffset, 0x28, 0x24,
	// ldrsw Xd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ························  (imm in [0, 2])
	2, MatX, MatRefIndex, 0x28, 0x2c,

	2,
	// ldset Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x38,
	// ldset Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0x40,

	2,
	// ldseta Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x48,
	// ldseta Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0x50,

	1,
	// ldsetab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x58,

	1,
	// ldsetah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x60,

	2,
	// ldsetal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x68,
	// ldsetal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0x70,

	1,
	// ldsetalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x78,

	1,
	// ldsetalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x80,

	1,
	// ldsetb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x88,

	1,
	// ldseth Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x90,

	2,
	// ldsetl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0x98,
	// ldsetl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0xa0,

	1,
	// ldsetlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xa8,

	1,
	// ldsetlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xb0,

	2,
	// ldsmax Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xb8,
	// ldsmax Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0xc0,

	2,
	// ldsmaxa Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xc8,
	// ldsmaxa Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0xd0,

	1,
	// ldsmaxab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xd8,

	1,
	// ldsmaxah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xe0,

	2,
	// ldsmaxal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xe8,
	// ldsmaxal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x28, 0xf0,

	1,
	// ldsmaxalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x28, 0xf8,

	1,
	// ldsmaxalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x0,

	1,
	// ldsmaxb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x8,

	1,
	// ldsmaxh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x10,

	2,
	// ldsmaxl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x18,
	// ldsmaxl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x29, 0x20,

	1,
	// ldsmaxlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x28,

	1,
	// ldsmaxlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x30,

	2,
	// ldsmin Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x38,
	// ldsmin Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x29, 0x40,

	2,
	// ldsmina Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x48,
	// ldsmina Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x29, 0x50,

	1,
	// ldsminab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x58,

	1,
	// ldsminah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x60,

	2,
	// ldsminal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x68,
	// ldsminal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x29, 0x70,

	1,
	// ldsminalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x78,

	1,
	// ldsminalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x80,

	1,
	// ldsminb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x88,

	1,
	// ldsminh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x90,

	2,
	// ldsminl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0x98,
	// ldsminl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x29, 0xa0,

	1,
	// ldsminlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0xa8,

	1,
	// ldsminlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x29, 0xb0,

	2,
	// ldtr Wd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x29, 0xb8,
	// ldtr Xd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x29, 0xc0,

	1,
	// ldtrb Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x29, 0xc8,

	1,
	// ldtrh Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x29, 0xd0,

	2,
	// ldtrsb Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x29, 0xd8,
	// ldtrsb Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x29, 0xe0,

	2,
	// ldtrsh Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x29, 0xe8,
	// ldtrsh Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x29, 0xf0,

	1,
	// ldtrsw Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x29, 0xf8,

	2,
	// ldumax Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x0,
	// ldumax Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0x8,

	2,
	// ldumaxa Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x10,
	// ldumaxa Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0x18,

	1,
	// ldumaxab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x20,

	1,
	// ldumaxah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x28,

	2,
	// ldumaxal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x30,
	// ldumaxal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0x38,

	1,
	// ldumaxalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x40,

	1,
	// ldumaxalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x48,

	1,
	// ldumaxb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x50,

	1,
	// ldumaxh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x58,

	2,
	// ldumaxl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x60,
	// ldumaxl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0x68,

	1,
	// ldumaxlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x70,

	1,
	// ldumaxlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x78,

	2,
	// ldumin Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x80,
	// ldumin Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0x88,

	2,
	// ldumina Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0x90,
	// ldumina Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0x98,

	1,
	// lduminab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xa0,

	1,
	// lduminah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xa8,

	2,
	// lduminal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xb0,
	// lduminal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0xb8,

	1,
	// lduminalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xc0,

	1,
	// lduminalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xc8,

	1,
	// lduminb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xd0,

	1,
	// lduminh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xd8,

	2,
	// lduminl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xe0,
	// lduminl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2a, 0xe8,

	1,
	// lduminlb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xf0,

	1,
	// lduminlh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2a, 0xf8,

	7,
	// ldur Bd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatB, MatRefOffset, 0x2b, 0x0,
	// ldur Hd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatH, MatRefOffset, 0x2b, 0x8,
	// ldur Sd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatS, MatRefOffset, 0x2b, 0x10,
	// ldur Dd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatD, MatRefOffset, 0x2b, 0x18,
	// ldur Qd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatQ, MatRefOffset, 0x2b, 0x20,
	// ldur Wd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x2b, 0x28,
	// ldur Xd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x2b, 0x30,

	1,
	// ldurb Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x2b, 0x38,

	1,
	// ldurh Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x2b, 0x40,

	2,
	// ldursb Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x2b, 0x48,
	// ldursb Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x2b, 0x50,

	2,
	// ldursh Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x2b, 0x58,
	// ldursh Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x2b, 0x60,

	1,
	// ldursw Xd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x2b, 0x68,

	2,
	// ldxp Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x2b, 0x70,
	// ldxp Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x2b, 0x78,

	2,
	// ldxr Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x2b, 0x80,
	// ldxr Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x2b, 0x87,

	1,
	// ldxrb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x2b, 0x8e,

	1,
	// ldxrh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x2b, 0x95,

	4,
	// lsl Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2b, 0x9c,
	// lsl Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2b, 0xa4,
	// lsl Wd, Wn, #imm  ·····························································  (0 <= imm < 32)
	3, MatW, MatW, MatImm, 0x2b, 0xac,
	// lsl Xd, Xn, #imm  ·····························································  (0 <= imm < 64)
	3, MatX, MatX, MatImm, 0x2b, 0xbb,

	2,
	// lslv Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2b, 0xca,
	// lslv Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2b, 0xd2,

	4,
	// lsr Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2b, 0xda,
	// lsr Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2b, 0xe2,
	// lsr Wd, Wn, #imm  ·····························································  (0 <= imm < 32)
	3, MatW, MatW, MatImm, 0x2b, 0xea,
	// lsr Xd, Xn, #imm  ·····························································  (0 <= imm < 64)
	3, MatX, MatX, MatImm, 0x2b, 0xf4,

	2,
	// lsrv Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2b, 0xfe,
	// lsrv Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2c, 0x6,

	2,
	// madd Wd, Wn, Wm, Wa
	4, MatW, MatW, MatW, MatW, 0x2c, 0xe,
	// madd Xd, Xn, Xm, Xa
	4, MatX, MatX, MatX, MatX, 0x2c, 0x17,

	5,
	// mla Vd.8H, Vn.8H, Vm.H[i]  ···························································  (m < 16)
	// mla Vd.4H, Vn.4H, Vm.H[i]  ···························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x2c, 0x20,
	// mla Vd.4S, Vn.4S, Vm.S[i]
	// mla Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x2c, 0x2b,
	// mla Vd.16B, Vn.16B, Vm.16B
	// mla Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x2c, 0x36,
	// mla Vd.8H, Vn.8H, Vm.8H
	// mla Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x2c, 0x3f,
	// mla Vd.4S, Vn.4S, Vm.4S
	// mla Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x2c, 0x48,

	5,
	// mls Vd.8H, Vn.8H, Vm.H[i]  ···························································  (m < 16)
	// mls Vd.4H, Vn.4H, Vm.H[i]  ···························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x2c, 0x51,
	// mls Vd.4S, Vn.4S, Vm.S[i]
	// mls Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x2c, 0x5c,
	// mls Vd.16B, Vn.16B, Vm.16B
	// mls Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x2c, 0x67,
	// mls Vd.8H, Vn.8H, Vm.8H
	// mls Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x2c, 0x70,
	// mls Vd.4S, Vn.4S, Vm.4S
	// mls Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x2c, 0x79,

	2,
	// mneg Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2c, 0x82,
	// mneg Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2c, 0x8a,

	25,
	// mov Wd, Wn
	2, MatW, MatW, 0x2c, 0x92,
	// mov Xd, Xn
	2, MatX, MatX, 0x2c, 0x99,
	// mov Wd|WSP, Wn|WSP
	2, MatWSP, MatWSP, 0x2c, 0xa0,
	// mov Xd|SP, Xn|SP
	2, MatXSP, MatXSP, 0x2c, 0xa7,
	// mov Bd, Vn.B[i]
	2, MatB, MatVElement, byte(BYTE), 0x2c, 0xae,
	// mov Hd, Vn.H[i]
	2, MatH, MatVElement, byte(WORD), 0x2c, 0xb8,
	// mov Sd, Vn.S[i]
	2, MatS, MatVElement, byte(DWORD), 0x2c, 0xc2,
	// mov Dd, Vn.D[i]
	2, MatD, MatVElement, byte(QWORD), 0x2c, 0xcc,
	// mov Vd.B[i], Vn.B[i]
	2, MatVElement, byte(BYTE), MatVElement, byte(BYTE), 0x2c, 0xd6,
	// mov Vd.H[i], Vn.H[i]
	2, MatVElement, byte(WORD), MatVElement, byte(WORD), 0x2c, 0xe3,
	// mov Vd.S[i], Vn.S[i]
	2, MatVElement, byte(DWORD), MatVElement, byte(DWORD), 0x2c, 0xf0,
	// mov Vd.D[i], Vn.D[i]
	2, MatVElement, byte(QWORD), MatVElement, byte(QWORD), 0x2c, 0xfd,
	// mov Vd.B[i], Wn
	2, MatVElement, byte(BYTE), MatW, 0x2d, 0xa,
	// mov Vd.H[i], Wn
	2, MatVElement, byte(WORD), MatW, 0x2d, 0x14,
	// mov Vd.S[i], Wn
	2, MatVElement, byte(DWORD), MatW, 0x2d, 0x1e,
	// mov Vd.D[i], Xn
	2, MatVElement, byte(QWORD), MatX, 0x2d, 0x28,
	// mov INVERTED, Wn, #imm  ·········································  (imm is 32-bit inverted wide)
	3, MatLitSymbol, byte(INVERTED), MatW, MatImm, 0x2d, 0x32,
	// mov INVERTED, Xn, #imm  ·········································  (imm is 64-bit inverted wide)
	3, MatLitSymbol, byte(INVERTED), MatX, MatImm, 0x2d, 0x3b,
	// mov Wd, #imm  ····························································  (imm is 32-bit wide)
	2, MatW, MatImm, 0x2d, 0x44,
	// mov Xd, #imm  ····························································  (imm is 64-bit wide)
	2, MatX, MatImm, 0x2d, 0x4d,
	// mov Vd.16B, Vn.16B
	// mov Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x2d, 0x56,
	// mov LOGICAL, Wn|WSP, #imm  ············································  (imm is 32-bit logical)
	3, MatLitSymbol, byte(LOGICAL), MatWSP, MatImm, 0x2d, 0x60,
	// mov LOGICAL, Xn|SP, #imm  ·············································  (imm is 64-bit logical)
	3, MatLitSymbol, byte(LOGICAL), MatXSP, MatImm, 0x2d, 0x69,
	// mov Wd, Vn.S[i]
	2, MatW, MatVElement, byte(DWORD), 0x2d, 0x72,
	// mov Xd, Vn.D[i]
	2, MatX, MatVElement, byte(QWORD), 0x2d, 0x7c,

	6,
	// movi Vd.16B, #imm1 {, LSL #imm2 }  ·······························  (0 <= imm1 < 256, imm2 == 0)
	// movi Vd.8B, #imm1 {, LSL #imm2 }  ································  (0 <= imm1 < 256, imm2 == 0)
	4, MatV, byte(BYTE), MatImm, MatEnd, MatLitMod, SymLSL, 0x2d, 0x86,
	// movi Vd.8H, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 256, imm2 in [0, 8])
	// movi Vd.4H, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 256, imm2 in [0, 8])
	4, MatV, byte(WORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x2d, 0x9b,
	// movi Vd.4S, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	// movi Vd.2S, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	4, MatV, byte(DWORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x2d, 0xb0,
	// movi Vd.4S, #imm1, MSL #imm2  ······························  (0 <= imm1 < 256, imm2 in [8, 16])
	// movi Vd.2S, #imm1, MSL #imm2  ······························  (0 <= imm1 < 256, imm2 in [8, 16])
	3, MatV, byte(DWORD), MatImm, MatLitMod, SymMSL, 0x2d, 0xc5,
	// movi Dd, #imm  ·····························································  (imm is stretched)
	2, MatD, MatImm, 0x2d, 0xda,
	// movi Vd.2D, #imm  ··························································  (imm is stretched)
	2, MatVStatic, byte(QWORD), 2, MatImm, 0x2d, 0xe3,

	2,
	// movk Wd, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 65536, imm2 in [0, 16])
	4, MatW, MatImm, MatEnd, MatLitMod, SymLSL, 0x2d, 0xec,
	// movk Xd, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 65536, imm2 in [0, 16, 32, 48])
	4, MatX, MatImm, MatEnd, MatLitMod, SymLSL, 0x2d, 0xf8,

	2,
	// movn Wd, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 65536, imm2 in [0, 16])
	4, MatW, MatImm, MatEnd, MatLitMod, SymLSL, 0x2e, 0x4,
	// movn Xd, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 65536, imm2 in [0, 16, 32, 48])
	4, MatX, MatImm, MatEnd, MatLitMod, SymLSL, 0x2e, 0x10,

	2,
	// movz Wd, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 65536, imm2 in [0, 16])
	4, MatW, MatImm, MatEnd, MatLitMod, SymLSL, 0x2e, 0x1c,
	// movz Xd, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 65536, imm2 in [0, 16, 32, 48])
	4, MatX, MatImm, MatEnd, MatLitMod, SymLSL, 0x2e, 0x28,

	1,
	// mrs Xd, #imm  ······························································  (0 <= imm < 32768)
	2, MatX, MatImm, 0x2e, 0x34,

	2,
	// msr <symbol>, #imm  ···························································  (0 <= imm < 16)
	2, MatSymbol, MatImm, 0x2e, 0x3d,
	// msr #imm, Xn  ······························································  (0 <= imm < 32768)
	2, MatImm, MatX, 0x2e, 0x48,

	2,
	// msub Wd, Wn, Wm, Wa
	4, MatW, MatW, MatW, MatW, 0x2e, 0x51,
	// msub Xd, Xn, Xm, Xa
	4, MatX, MatX, MatX, MatX, 0x2e, 0x5a,

	7,
	// mul Vd.8H, Vn.8H, Vm.H[i]  ···························································  (m < 16)
	// mul Vd.4H, Vn.4H, Vm.H[i]  ···························································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x2e, 0x63,
	// mul Vd.4S, Vn.4S, Vm.S[i]
	// mul Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x2e, 0x6e,
	// mul Vd.16B, Vn.16B, Vm.16B
	// mul Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x2e, 0x79,
	// mul Vd.8H, Vn.8H, Vm.8H
	// mul Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x2e, 0x82,
	// mul Vd.4S, Vn.4S, Vm.4S
	// mul Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x2e, 0x8b,
	// mul Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x2e, 0x94,
	// mul Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x2e, 0x9c,

	3,
	// mvn Wd, Wn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 32)
	4, MatW, MatW, MatEnd, MatMod, SymShifts, 0x2e, 0xa4,
	// mvn Xd, Xn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 64)
	4, MatX, MatX, MatEnd, MatMod, SymShifts, 0x2e, 0xaf,
	// mvn Vd.16B, Vn.16B
	// mvn Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x2e, 0xba,

	3,
	// mvni Vd.8H, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 256, imm2 in [0, 8])
	// mvni Vd.4H, #imm1 {, LSL #imm2 }  ···························  (0 <= imm1 < 256, imm2 in [0, 8])
	4, MatV, byte(WORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x2e, 0xc2,
	// mvni Vd.4S, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	// mvni Vd.2S, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	4, MatV, byte(DWORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x2e, 0xd7,
	// mvni Vd.4S, #imm1, MSL #imm2  ······························  (0 <= imm1 < 256, imm2 in [8, 16])
	// mvni Vd.2S, #imm1, MSL #imm2  ······························  (0 <= imm1 < 256, imm2 in [8, 16])
	3, MatV, byte(DWORD), MatImm, MatLitMod, SymMSL, 0x2e, 0xec,

	7,
	// neg Wd, Wn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 32)
	4, MatW, MatW, MatEnd, MatMod, SymShifts, 0x2f, 0x1,
	// neg Xd, Xn {, LSL|LSR|ASR #imm }  ·············································  (0 <= imm < 64)
	4, MatX, MatX, MatEnd, MatMod, SymShifts, 0x2f, 0xc,
	// neg Dd, Dn
	2, MatD, MatD, 0x2f, 0x17,
	// neg Vd.16B, Vn.16B
	// neg Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x2f, 0x1e,
	// neg Vd.8H, Vn.8H
	// neg Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x2f, 0x26,
	// neg Vd.4S, Vn.4S
	// neg Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x2f, 0x2e,
	// neg Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x2f, 0x36,

	2,
	// negs Wd, Wn {, LSL|LSR|ASR #imm }  ············································  (0 <= imm < 32)
	4, MatW, MatW, MatEnd, MatMod, SymShifts, 0x2f, 0x3e,
	// negs Xd, Xn {, LSL|LSR|ASR #imm }  ············································  (0 <= imm < 64)
	4, MatX, MatX, MatEnd, MatMod, SymShifts, 0x2f, 0x49,

	2,
	// ngc Wd, Wn
	2, MatW, MatW, 0x2f, 0x54,
	// ngc Xd, Xn
	2, MatX, MatX, 0x2f, 0x5b,

	2,
	// ngcs Wd, Wn
	2, MatW, MatW, 0x2f, 0x62,
	// ngcs Xd, Xn
	2, MatX, MatX, 0x2f, 0x69,

	1,
	// nop
	0, 0x2f, 0x70,

	1,
	// not Vd.16B, Vn.16B
	// not Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x2f, 0x75,

	3,
	// orn Vd.16B, Vn.16B, Vm.16B
	// orn Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x2f, 0x7d,
	// orn Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0x2f, 0x86,
	// orn Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0x2f, 0x92,

	7,
	// orr Vd.8H, #imm1 {, LSL #imm2 }  ····························  (0 <= imm1 < 256, imm2 in [0, 8])
	// orr Vd.4H, #imm1 {, LSL #imm2 }  ····························  (0 <= imm1 < 256, imm2 in [0, 8])
	4, MatV, byte(WORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x2f, 0x9e,
	// orr Vd.4S, #imm1 {, LSL #imm2 }  ····················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	// orr Vd.2S, #imm1 {, LSL #imm2 }  ····················  (0 <= imm1 < 256, imm2 in [0, 8, 16, 24])
	4, MatV, byte(DWORD), MatImm, MatEnd, MatLitMod, SymLSL, 0x2f, 0xb3,
	// orr Vd.16B, Vn.16B, Vm.16B
	// orr Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x2f, 0xc8,
	// orr Wd|WSP, Wn, #imm  ·················································  (imm is 32-bit logical)
	3, MatWSP, MatW, MatImm, 0x2f, 0xd1,
	// orr Xd|SP, Xn, #imm  ··················································  (imm is 64-bit logical)
	3, MatXSP, MatX, MatImm, 0x2f, 0xdb,
	// orr Wd, Wn, Wm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymRotates, 0x2f, 0xe5,
	// orr Xd, Xn, Xm {, LSL|LSR|ASR|ROR #imm }  ·····································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymRotates, 0x2f, 0xf1,

	1,
	// pacda Xd, Xn|SP
	2, MatX, MatXSP, 0x2f, 0xfd,

	1,
	// pacdb Xd, Xn|SP
	2, MatX, MatXSP, 0x30, 0x4,

	1,
	// pacdza Xd
	1, MatX, 0x30, 0xb,

	1,
	// pacdzb Xd
	1, MatX, 0x30, 0x11,

	1,
	// pacga Xd, Xn, Xm|SP
	3, MatX, MatX, MatXSP, 0x30, 0x17,

	1,
	// pacia Xd, Xn|SP
	2, MatX, MatXSP, 0x30, 0x1f,

	1,
	// pacia1716
	0, 0x30, 0x26,

	1,
	// paciasp
	0, 0x30, 0x2b,

	1,
	// paciaz
	0, 0x30, 0x30,

	1,
	// pacib Xd, Xn|SP
	2, MatX, MatXSP, 0x30, 0x35,

	1,
	// pacib1716
	0, 0x30, 0x3c,

	1,
	// pacibsp
	0, 0x30, 0x41,

	1,
	// pacibz
	0, 0x30, 0x46,

	1,
	// paciza Xd
	1, MatX, 0x30, 0x4b,

	1,
	// pacizb Xd
	1, MatX, 0x30, 0x51,

	1,
	// pmul Vd.16B, Vn.16B, Vm.16B
	// pmul Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x30, 0x57,

	2,
	// pmull Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x30, 0x60,
	// pmull Vd.1Q, Vn.1D, Vm.1D
	3, MatVStatic, byte(OWORD), 1, MatVStatic, byte(QWORD), 1, MatVStatic, byte(QWORD), 1, 0x30, 0x68,

	2,
	// pmull2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x30, 0x70,
	// pmull2 Vd.1Q, Vn.2D, Vm.2D
	3, MatVStatic, byte(OWORD), 1, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x30, 0x78,

	2,
	// prfm #imm, <offset>  ························  (0 <= imm < 32, offset >> 2 is 19-bit (+/- 1 MB))
	2, MatImm, MatOffset, 0x30, 0x80,
	// prfm #imm1, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm2 }]  ····  (0 <= imm1 < 32, imm2 in [0, 3])
	2, MatImm, MatRefIndex, 0x30, 0x8a,

	1,
	// prfum #imm1, [Xn|SP {, #imm2 }]  ·························  (0 <= imm1 < 32, -256 <= imm2 < 256)
	2, MatImm, MatRefOffset, 0x30, 0x98,

	1,
	// psb CSYNC
	1, MatLitSymbol, byte(CSYNC), 0x30, 0xa2,

	1,
	// pssbb
	0, 0x30, 0xa7,

	3,
	// raddhn Vd.8B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x30, 0xac,
	// raddhn Vd.4H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x30, 0xb4,
	// raddhn Vd.2S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x30, 0xbc,

	3,
	// raddhn2 Vd.16B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x30, 0xc4,
	// raddhn2 Vd.8H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x30, 0xcc,
	// raddhn2 Vd.4S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x30, 0xd4,

	1,
	// rax1 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x30, 0xdc,

	3,
	// rbit Vd.16B, Vn.16B
	// rbit Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x30, 0xe4,
	// rbit Wd, Wn
	2, MatW, MatW, 0x30, 0xec,
	// rbit Xd, Xn
	2, MatX, MatX, 0x30, 0xf3,

	2,
	// ret Xd
	1, MatX, 0x30, 0xfa,
	// ret
	0, 0x31, 0x0,

	1,
	// retaa
	0, 0x31, 0x5,

	1,
	// retab
	0, 0x31, 0xa,

	2,
	// rev Wd, Wn
	2, MatW, MatW, 0x31, 0xf,
	// rev Xd, Xn
	2, MatX, MatX, 0x31, 0x16,

	3,
	// rev16 Vd.16B, Vn.16B
	// rev16 Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x31, 0x1d,
	// rev16 Wd, Wn
	2, MatW, MatW, 0x31, 0x25,
	// rev16 Xd, Xn
	2, MatX, MatX, 0x31, 0x2c,

	3,
	// rev32 Vd.16B, Vn.16B
	// rev32 Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x31, 0x33,
	// rev32 Vd.8H, Vn.8H
	// rev32 Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x31, 0x3b,
	// rev32 Xd, Xn
	2, MatX, MatX, 0x31, 0x43,

	4,
	// rev64 Vd.16B, Vn.16B
	// rev64 Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x31, 0x4a,
	// rev64 Vd.8H, Vn.8H
	// rev64 Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x31, 0x52,
	// rev64 Vd.4S, Vn.4S
	// rev64 Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x31, 0x5a,
	// rev64 Xd, Xn
	2, MatX, MatX, 0x31, 0x62,

	1,
	// rmif Xd, #imm1, #imm2  ·······································  (0 <= imm1 < 64, 0 <= imm2 < 16)
	3, MatX, MatImm, MatImm, 0x31, 0x69,

	4,
	// ror Wd, Wn, #imm  ·····························································  (0 <= imm < 32)
	3, MatW, MatW, MatImm, 0x31, 0x75,
	// ror Xd, Xn, #imm  ·····························································  (0 <= imm < 64)
	3, MatX, MatX, MatImm, 0x31, 0x81,
	// ror Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x31, 0x8d,
	// ror Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x31, 0x95,

	2,
	// rorv Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x31, 0x9d,
	// rorv Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x31, 0xa5,

	3,
	// rshrn Vd.8B, Vn.8H, #imm  ······················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x31, 0xad,
	// rshrn Vd.4H, Vn.4S, #imm  ·····················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x31, 0xb8,
	// rshrn Vd.2S, Vn.2D, #imm  ·····················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x31, 0xc3,

	3,
	// rshrn2 Vd.16B, Vn.8H, #imm  ····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x31, 0xce,
	// rshrn2 Vd.8H, Vn.4S, #imm  ····················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x31, 0xd9,
	// rshrn2 Vd.4S, Vn.2D, #imm  ····················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x31, 0xe4,

	3,
	// rsubhn Vd.8B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x31, 0xef,
	// rsubhn Vd.4H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x31, 0xf7,
	// rsubhn Vd.2S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x31, 0xff,

	3,
	// rsubhn2 Vd.16B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x32, 0x7,
	// rsubhn2 Vd.8H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x32, 0xf,
	// rsubhn2 Vd.4S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x32, 0x17,

	3,
	// saba Vd.16B, Vn.16B, Vm.16B
	// saba Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x32, 0x1f,
	// saba Vd.8H, Vn.8H, Vm.8H
	// saba Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x32, 0x28,
	// saba Vd.4S, Vn.4S, Vm.4S
	// saba Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x32, 0x31,

	3,
	// sabal Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x32, 0x3a,
	// sabal Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x32, 0x42,
	// sabal Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x32, 0x4a,

	3,
	// sabal2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x32, 0x52,
	// sabal2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x32, 0x5a,
	// sabal2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x32, 0x62,

	3,
	// sabd Vd.16B, Vn.16B, Vm.16B
	// sabd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x32, 0x6a,
	// sabd Vd.8H, Vn.8H, Vm.8H
	// sabd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x32, 0x73,
	// sabd Vd.4S, Vn.4S, Vm.4S
	// sabd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x32, 0x7c,

	3,
	// sabdl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x32, 0x85,
	// sabdl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x32, 0x8d,
	// sabdl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x32, 0x95,

	3,
	// sabdl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x32, 0x9d,
	// sabdl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x32, 0xa5,
	// sabdl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x32, 0xad,

	3,
	// sadalp Vd.8H, Vn.16B
	// sadalp Vd.4H, Vn.8B
	2, MatV, byte(WORD), MatV, byte(BYTE), 0x32, 0xb5,
	// sadalp Vd.4S, Vn.8H
	// sadalp Vd.2S, Vn.4H
	2, MatV, byte(DWORD), MatV, byte(WORD), 0x32, 0xbd,
	// sadalp Vd.2D, Vn.4S
	// sadalp Vd.1D, Vn.2S
	2, MatV, byte(QWORD), MatV, byte(DWORD), 0x32, 0xc5,

	3,
	// saddl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x32, 0xcd,
	// saddl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x32, 0xd5,
	// saddl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x32, 0xdd,

	3,
	// saddl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x32, 0xe5,
	// saddl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x32, 0xed,
	// saddl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x32, 0xf5,

	3,
	// saddlp Vd.8H, Vn.16B
	// saddlp Vd.4H, Vn.8B
	2, MatV, byte(WORD), MatV, byte(BYTE), 0x32, 0xfd,
	// saddlp Vd.4S, Vn.8H
	// saddlp Vd.2S, Vn.4H
	2, MatV, byte(DWORD), MatV, byte(WORD), 0x33, 0x5,
	// saddlp Vd.2D, Vn.4S
	// saddlp Vd.1D, Vn.2S
	2, MatV, byte(QWORD), MatV, byte(DWORD), 0x33, 0xd,

	3,
	// saddlv Hd, Vn.16B
	// saddlv Hd, Vn.8B
	2, MatH, MatV, byte(BYTE), 0x33, 0x15,
	// saddlv Sd, Vn.8H
	// saddlv Sd, Vn.4H
	2, MatS, MatV, byte(WORD), 0x33, 0x1d,
	// saddlv Dd, Vn.4S
	2, MatD, MatVStatic, byte(DWORD), 4, 0x33, 0x25,

	3,
	// saddw Vd.8H, Vn.8H, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, 0x33, 0x2d,
	// saddw Vd.4S, Vn.4S, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0x33, 0x35,
	// saddw Vd.2D, Vn.2D, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0x33, 0x3d,

	3,
	// saddw2 Vd.8H, Vn.8H, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, 0x33, 0x45,
	// saddw2 Vd.4S, Vn.4S, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0x33, 0x4d,
	// saddw2 Vd.2D, Vn.2D, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0x33, 0x55,

	1,
	// sb
	0, 0x33, 0x5d,

	2,
	// sbc Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x33, 0x62,
	// sbc Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x33, 0x6a,

	2,
	// sbcs Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x33, 0x72,
	// sbcs Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x33, 0x7a,

	2,
	// sbfiz Wd, Wn, #imm1, #imm2  ···············  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	4, MatW, MatW, MatImm, MatImm, 0x33, 0x82,
	// sbfiz Xd, Xn, #imm1, #imm2  ···············  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x33, 0x92,

	2,
	// sbfm Wd, Wn, #imm1, #imm2  ···································  (0 <= imm1 < 32, 0 <= imm2 < 32)
	4, MatW, MatW, MatImm, MatImm, 0x33, 0xa2,
	// sbfm Xd, Xn, #imm1, #imm2  ·················  (0 <= imm1 < 64, 0 < imm2 < 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x33, 0xaf,

	2,
	// sbfx Wd, Wn, #imm1, #imm2  ················  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	4, MatW, MatW, MatImm, MatImm, 0x33, 0xbe,
	// sbfx Xd, Xn, #imm1, #imm2  ················  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x33, 0xcd,

	24,
	// scvtf Hd, Hn, #imm  ···························································  (0 < imm <= 16)
	3, MatH, MatH, MatImm, 0x33, 0xdc,
	// scvtf Sd, Sn, #imm  ···························································  (0 < imm <= 32)
	3, MatS, MatS, MatImm, 0x33, 0xe9,
	// scvtf Dd, Dn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x33, 0xf6,
	// scvtf Vd.8H, Vn.8H, #imm  ·····················································  (0 < imm <= 16)
	// scvtf Vd.4H, Vn.4H, #imm  ·····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x34, 0x3,
	// scvtf Vd.4S, Vn.4S, #imm  ·····················································  (0 < imm <= 32)
	// scvtf Vd.2S, Vn.2S, #imm  ·····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x34, 0xf,
	// scvtf Vd.2D, Vn.2D, #imm  ·····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x34, 0x1b,
	// scvtf Hd, Hn
	2, MatH, MatH, 0x34, 0x27,
	// scvtf Sd, Sn
	2, MatS, MatS, 0x34, 0x2e,
	// scvtf Dd, Dn
	2, MatD, MatD, 0x34, 0x35,
	// scvtf Vd.8H, Vn.8H
	// scvtf Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x34, 0x3c,
	// scvtf Vd.4S, Vn.4S
	// scvtf Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x34, 0x44,
	// scvtf Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x34, 0x4c,
	// scvtf Hd, Wn, #imm  ···························································  (0 < imm <= 32)
	3, MatH, MatW, MatImm, 0x34, 0x54,
	// scvtf Sd, Wn, #imm  ···························································  (0 < imm <= 32)
	3, MatS, MatW, MatImm, 0x34, 0x61,
	// scvtf Dd, Wn, #imm  ···························································  (0 < imm <= 32)
	3, MatD, MatW, MatImm, 0x34, 0x6e,
	// scvtf Hd, Xn, #imm  ···························································  (0 < imm <= 64)
	3, MatH, MatX, MatImm, 0x34, 0x7b,
	// scvtf Sd, Xn, #imm  ···························································  (0 < imm <= 64)
	3, MatS, MatX, MatImm, 0x34, 0x86,
	// scvtf Dd, Xn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatX, MatImm, 0x34, 0x91,
	// scvtf Hd, Wn
	2, MatH, MatW, 0x34, 0x9c,
	// scvtf Sd, Wn
	2, MatS, MatW, 0x34, 0xa3,
	// scvtf Dd, Wn
	2, MatD, MatW, 0x34, 0xaa,
	// scvtf Hd, Xn
	2, MatH, MatX, 0x34, 0xb1,
	// scvtf Sd, Xn
	2, MatS, MatX, 0x34, 0xb8,
	// scvtf Dd, Xn
	2, MatD, MatX, 0x34, 0xbf,

	2,
	// sdiv Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x34, 0xc6,
	// sdiv Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x34, 0xce,

	4,
	// sdot Vd.2S, Vn.8B, Vm.4B[i]
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(BYTE), 8, MatVStaticElement, byte(BYTE), 4, 0x34, 0xd6,
	// sdot Vd.4S, Vn.16B, Vm.4B[i]
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(BYTE), 16, MatVStaticElement, byte(BYTE), 4, 0x34, 0xe0,
	// sdot Vd.2S, Vn.8B, Vm.8B
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x34, 0xea,
	// sdot Vd.4S, Vn.16B, Vm.16B
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x34, 0xf2,

	1,
	// setf16 Wd
	1, MatW, 0x34, 0xfa,

	1,
	// setf8 Wd
	1, MatW, 0x35, 0x0,

	1,
	// sev
	0, 0x35, 0x6,

	1,
	// sevl
	0, 0x35, 0xb,

	1,
	// sha1c Qd, Sn, Vm.4S
	3, MatQ, MatS, MatVStatic, byte(DWORD), 4, 0x35, 0x10,

	1,
	// sha1h Sd, Sn
	2, MatS, MatS, 0x35, 0x18,

	1,
	// sha1m Qd, Sn, Vm.4S
	3, MatQ, MatS, MatVStatic, byte(DWORD), 4, 0x35, 0x1f,

	1,
	// sha1p Qd, Sn, Vm.4S
	3, MatQ, MatS, MatVStatic, byte(DWORD), 4, 0x35, 0x27,

	1,
	// sha1su0 Vd.4S, Vn.4S, Vm.4S
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x35, 0x2f,

	1,
	// sha1su1 Vd.4S, Vn.4S
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x35, 0x37,

	1,
	// sha256h Qd, Qn, Vm.4S
	3, MatQ, MatQ, MatVStatic, byte(DWORD), 4, 0x35, 0x3e,

	1,
	// sha256h2 Qd, Qn, Vm.4S
	3, MatQ, MatQ, MatVStatic, byte(DWORD), 4, 0x35, 0x46,

	1,
	// sha256su0 Vd.4S, Vn.4S
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x35, 0x4e,

	1,
	// sha256su1 Vd.4S, Vn.4S, Vm.4S
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x35, 0x55,

	1,
	// sha512h Qd, Qn, Vm.2D
	3, MatQ, MatQ, MatVStatic, byte(QWORD), 2, 0x35, 0x5d,

	1,
	// sha512h2 Qd, Qn, Vm.2D
	3, MatQ, MatQ, MatVStatic, byte(QWORD), 2, 0x35, 0x65,

	1,
	// sha512su0 Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x35, 0x6d,

	1,
	// sha512su1 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x35, 0x74,

	3,
	// shadd Vd.16B, Vn.16B, Vm.16B
	// shadd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x35, 0x7c,
	// shadd Vd.8H, Vn.8H, Vm.8H
	// shadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x35, 0x85,
	// shadd Vd.4S, Vn.4S, Vm.4S
	// shadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x35, 0x8e,

	5,
	// shl Dd, Dn, #imm  ·····························································  (0 <= imm < 64)
	3, MatD, MatD, MatImm, 0x35, 0x97,
	// shl Vd.16B, Vn.16B, #imm  ······················································  (0 <= imm < 8)
	// shl Vd.8B, Vn.8B, #imm  ························································  (0 <= imm < 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x35, 0xa1,
	// shl Vd.8H, Vn.8H, #imm  ·······················································  (0 <= imm < 16)
	// shl Vd.4H, Vn.4H, #imm  ·······················································  (0 <= imm < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x35, 0xac,
	// shl Vd.4S, Vn.4S, #imm  ·······················································  (0 <= imm < 32)
	// shl Vd.2S, Vn.2S, #imm  ·······················································  (0 <= imm < 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x35, 0xb7,
	// shl Vd.2D, Vn.2D, #imm  ·······················································  (0 <= imm < 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x35, 0xc2,

	3,
	// shll Vd.8H, Vn.8B, #8
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatLitInt, 8, 0x35, 0xcd,
	// shll Vd.4S, Vn.4H, #16
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatLitInt, 16, 0x35, 0xd4,
	// shll Vd.2D, Vn.2S, #32
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatLitInt, 32, 0x35, 0xdb,

	3,
	// shll2 Vd.8H, Vn.16B, #8
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatLitInt, 8, 0x35, 0xe2,
	// shll2 Vd.4S, Vn.8H, #16
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatLitInt, 16, 0x35, 0xe9,
	// shll2 Vd.2D, Vn.4S, #32
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatLitInt, 32, 0x35, 0xf0,

	3,
	// shrn Vd.8B, Vn.8H, #imm  ·······················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x35, 0xf7,
	// shrn Vd.4H, Vn.4S, #imm  ······················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x36, 0x2,
	// shrn Vd.2S, Vn.2D, #imm  ······················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x36, 0xd,

	3,
	// shrn2 Vd.16B, Vn.8H, #imm  ·····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x36, 0x18,
	// shrn2 Vd.8H, Vn.4S, #imm  ·····················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x36, 0x23,
	// shrn2 Vd.4S, Vn.2D, #imm  ·····················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x36, 0x2e,

	3,
	// shsub Vd.16B, Vn.16B, Vm.16B
	// shsub Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x36, 0x39,
	// shsub Vd.8H, Vn.8H, Vm.8H
	// shsub Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x36, 0x42,
	// shsub Vd.4S, Vn.4S, Vm.4S
	// shsub Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x36, 0x4b,

	5,
	// sli Dd, Dn, #imm  ·····························································  (0 <= imm < 64)
	3, MatD, MatD, MatImm, 0x36, 0x54,
	// sli Vd.16B, Vn.16B, #imm  ······················································  (0 <= imm < 8)
	// sli Vd.8B, Vn.8B, #imm  ························································  (0 <= imm < 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x36, 0x5e,
	// sli Vd.8H, Vn.8H, #imm  ·······················································  (0 <= imm < 16)
	// sli Vd.4H, Vn.4H, #imm  ·······················································  (0 <= imm < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x36, 0x69,
	// sli Vd.4S, Vn.4S, #imm  ·······················································  (0 <= imm < 32)
	// sli Vd.2S, Vn.2S, #imm  ·······················································  (0 <= imm < 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x36, 0x74,
	// sli Vd.2D, Vn.2D, #imm  ·······················································  (0 <= imm < 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x36, 0x7f,

	1,
	// sm3partw1 Vd.4S, Vn.4S, Vm.4S
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x36, 0x8a,

	1,
	// sm3partw2 Vd.4S, Vn.4S, Vm.4S
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x36, 0x92,

	1,
	// sm3ss1 Vd.4S, Vn.4S, Vm.4S, Va.4S
	4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x36, 0x9a,

	1,
	// sm3tt1a Vd.4S, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x36, 0xa3,

	1,
	// sm3tt1b Vd.4S, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x36, 0xae,

	1,
	// sm3tt2a Vd.4S, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x36, 0xb9,

	1,
	// sm3tt2b Vd.4S, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x36, 0xc4,

	1,
	// sm4e Vd.4S, Vn.4S
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x36, 0xcf,

	1,
	// sm4ekey Vd.4S, Vn.4S, Vm.4S
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x36, 0xd6,

	1,
	// smaddl Xd, Wn, Wm, Xa
	4, MatX, MatW, MatW, MatX, 0x36, 0xde,

	3,
	// smax Vd.16B, Vn.16B, Vm.16B
	// smax Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x36, 0xe7,
	// smax Vd.8H, Vn.8H, Vm.8H
	// smax Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x36, 0xf0,
	// smax Vd.4S, Vn.4S, Vm.4S
	// smax Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x36, 0xf9,

	3,
	// smaxp Vd.16B, Vn.16B, Vm.16B
	// smaxp Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x37, 0x2,
	// smaxp Vd.8H, Vn.8H, Vm.8H
	// smaxp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x37, 0xb,
	// smaxp Vd.4S, Vn.4S, Vm.4S
	// smaxp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x37, 0x14,

	3,
	// smaxv Bd, Vn.16B
	// smaxv Bd, Vn.8B
	2, MatB, MatV, byte(BYTE), 0x37, 0x1d,
	// smaxv Hd, Vn.8H
	// smaxv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x37, 0x25,
	// smaxv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x37, 0x2d,

	1,
	// smc #imm  ··································································  (0 <= imm < 65536)
	1, MatImm, 0x37, 0x35,

	3,
	// smin Vd.16B, Vn.16B, Vm.16B
	// smin Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x37, 0x3d,
	// smin Vd.8H, Vn.8H, Vm.8H
	// smin Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x37, 0x46,
	// smin Vd.4S, Vn.4S, Vm.4S
	// smin Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x37, 0x4f,

	3,
	// sminp Vd.16B, Vn.16B, Vm.16B
	// sminp Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x37, 0x58,
	// sminp Vd.8H, Vn.8H, Vm.8H
	// sminp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x37, 0x61,
	// sminp Vd.4S, Vn.4S, Vm.4S
	// sminp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x37, 0x6a,

	3,
	// sminv Bd, Vn.16B
	// sminv Bd, Vn.8B
	2, MatB, MatV, byte(BYTE), 0x37, 0x73,
	// sminv Hd, Vn.8H
	// sminv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x37, 0x7b,
	// sminv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x37, 0x83,

	5,
	// smlal Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x37, 0x8b,
	// smlal Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x37, 0x95,
	// smlal Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x37, 0x9f,
	// smlal Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x37, 0xa7,
	// smlal Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x37, 0xaf,

	5,
	// smlal2 Vd.4S, Vn.8H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x37, 0xb7,
	// smlal2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x37, 0xc1,
	// smlal2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x37, 0xcb,
	// smlal2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x37, 0xd3,
	// smlal2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x37, 0xdb,

	5,
	// smlsl Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x37, 0xe3,
	// smlsl Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x37, 0xed,
	// smlsl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x37, 0xf7,
	// smlsl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x37, 0xff,
	// smlsl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x38, 0x7,

	5,
	// smlsl2 Vd.4S, Vn.8H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x38, 0xf,
	// smlsl2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x38, 0x19,
	// smlsl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x38, 0x23,
	// smlsl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x38, 0x2b,
	// smlsl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x38, 0x33,

	1,
	// smnegl Xd, Wn, Wm
	3, MatX, MatW, MatW, 0x38, 0x3b,

	5,
	// smov Wd, Vn.B[i]
	2, MatW, MatVElement, byte(BYTE), 0x38, 0x43,
	// smov Wd, Vn.H[i]
	2, MatW, MatVElement, byte(WORD), 0x38, 0x4d,
	// smov Xd, Vn.B[i]
	2, MatX, MatVElement, byte(BYTE), 0x38, 0x57,
	// smov Xd, Vn.H[i]
	2, MatX, MatVElement, byte(WORD), 0x38, 0x61,
	// smov Xd, Vn.S[i]
	2, MatX, MatVElement, byte(DWORD), 0x38, 0x6b,

	1,
	// smsubl Xd, Wn, Wm, Xa
	4, MatX, MatW, MatW, MatX, 0x38, 0x75,

	1,
	// smulh Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x38, 0x7e,

	6,
	// smull Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x38, 0x86,
	// smull Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x38, 0x90,
	// smull Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x38, 0x9a,
	// smull Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x38, 0xa2,
	// smull Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x38, 0xaa,
	// smull Xd, Wn, Wm
	3, MatX, MatW, MatW, 0x38, 0xb2,

	5,
	// smull2 Vd.4S, Vn.8H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x38, 0xba,
	// smull2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x38, 0xc4,
	// smull2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x38, 0xce,
	// smull2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x38, 0xd6,
	// smull2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x38, 0xde,

	8,
	// sqabs Bd, Bn
	2, MatB, MatB, 0x38, 0xe6,
	// sqabs Hd, Hn
	2, MatH, MatH, 0x38, 0xed,
	// sqabs Sd, Sn
	2, MatS, MatS, 0x38, 0xf4,
	// sqabs Dd, Dn
	2, MatD, MatD, 0x38, 0xfb,
	// sqabs Vd.16B, Vn.16B
	// sqabs Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x39, 0x2,
	// sqabs Vd.8H, Vn.8H
	// sqabs Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x39, 0xa,
	// sqabs Vd.4S, Vn.4S
	// sqabs Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x39, 0x12,
	// sqabs Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x39, 0x1a,

	8,
	// sqadd Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x39, 0x22,
	// sqadd Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x39, 0x2a,
	// sqadd Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x39, 0x32,
	// sqadd Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x39, 0x3a,
	// sqadd Vd.16B, Vn.16B, Vm.16B
	// sqadd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x39, 0x42,
	// sqadd Vd.8H, Vn.8H, Vm.8H
	// sqadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x39, 0x4b,
	// sqadd Vd.4S, Vn.4S, Vm.4S
	// sqadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x39, 0x54,
	// sqadd Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x39, 0x5d,

	8,
	// sqdmlal Sd, Hn, Vm.H[i]  ·····························································  (m < 16)
	3, MatS, MatH, MatVElement, byte(WORD), 0x39, 0x66,
	// sqdmlal Dd, Sn, Vm.S[i]
	3, MatD, MatS, MatVElement, byte(DWORD), 0x39, 0x70,
	// sqdmlal Vd.4S, Vn.4H, Vm.H[i]  ·······················································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x39, 0x7a,
	// sqdmlal Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x39, 0x84,
	// sqdmlal Sd, Hn, Hm
	3, MatS, MatH, MatH, 0x39, 0x8e,
	// sqdmlal Dd, Sn, Sm
	3, MatD, MatS, MatS, 0x39, 0x96,
	// sqdmlal Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x39, 0x9e,
	// sqdmlal Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x39, 0xa6,

	4,
	// sqdmlal2 Vd.4S, Vn.8H, Vm.H[i]  ······················································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x39, 0xae,
	// sqdmlal2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x39, 0xb8,
	// sqdmlal2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x39, 0xc2,
	// sqdmlal2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x39, 0xca,

	8,
	// sqdmlsl Sd, Hn, Vm.H[i]  ·····························································  (m < 16)
	3, MatS, MatH, MatVElement, byte(WORD), 0x39, 0xd2,
	// sqdmlsl Dd, Sn, Vm.S[i]
	3, MatD, MatS, MatVElement, byte(DWORD), 0x39, 0xdc,
	// sqdmlsl Vd.4S, Vn.4H, Vm.H[i]  ·······················································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x39, 0xe6,
	// sqdmlsl Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x39, 0xf0,
	// sqdmlsl Sd, Hn, Hm
	3, MatS, MatH, MatH, 0x39, 0xfa,
	// sqdmlsl Dd, Sn, Sm
	3, MatD, MatS, MatS, 0x3a, 0x2,
	// sqdmlsl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x3a, 0xa,
	// sqdmlsl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x3a, 0x12,

	4,
	// sqdmlsl2 Vd.4S, Vn.8H, Vm.H[i]  ······················································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x3a, 0x1a,
	// sqdmlsl2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x3a, 0x24,
	// sqdmlsl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x3a, 0x2e,
	// sqdmlsl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x3a, 0x36,

	8,
	// sqdmulh Hd, Hn, Vm.H[i]  ·····························································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x3a, 0x3e,
	// sqdmulh Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x3a, 0x48,
	// sqdmulh Vd.8H, Vn.8H, Vm.H[i]  ·······················································  (m < 16)
	// sqdmulh Vd.4H, Vn.4H, Vm.H[i]  ·······················································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x3a, 0x52,
	// sqdmulh Vd.4S, Vn.4S, Vm.S[i]
	// sqdmulh Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x3a, 0x5d,
	// sqdmulh Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3a, 0x68,
	// sqdmulh Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3a, 0x70,
	// sqdmulh Vd.8H, Vn.8H, Vm.8H
	// sqdmulh Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3a, 0x78,
	// sqdmulh Vd.4S, Vn.4S, Vm.4S
	// sqdmulh Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3a, 0x81,

	8,
	// sqdmull Sd, Hn, Vm.H[i]  ·····························································  (m < 16)
	3, MatS, MatH, MatVElement, byte(WORD), 0x3a, 0x8a,
	// sqdmull Dd, Sn, Vm.S[i]
	3, MatD, MatS, MatVElement, byte(DWORD), 0x3a, 0x94,
	// sqdmull Vd.4S, Vn.4H, Vm.H[i]  ·······················································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x3a, 0x9e,
	// sqdmull Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x3a, 0xa8,
	// sqdmull Sd, Hn, Hm
	3, MatS, MatH, MatH, 0x3a, 0xb2,
	// sqdmull Dd, Sn, Sm
	3, MatD, MatS, MatS, 0x3a, 0xba,
	// sqdmull Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x3a, 0xc2,
	// sqdmull Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x3a, 0xca,

	4,
	// sqdmull2 Vd.4S, Vn.8H, Vm.H[i]  ······················································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x3a, 0xd2,
	// sqdmull2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x3a, 0xdc,
	// sqdmull2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x3a, 0xe6,
	// sqdmull2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x3a, 0xee,

	8,
	// sqneg Bd, Bn
	2, MatB, MatB, 0x3a, 0xf6,
	// sqneg Hd, Hn
	2, MatH, MatH, 0x3a, 0xfd,
	// sqneg Sd, Sn
	2, MatS, MatS, 0x3b, 0x4,
	// sqneg Dd, Dn
	2, MatD, MatD, 0x3b, 0xb,
	// sqneg Vd.16B, Vn.16B
	// sqneg Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x3b, 0x12,
	// sqneg Vd.8H, Vn.8H
	// sqneg Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x3b, 0x1a,
	// sqneg Vd.4S, Vn.4S
	// sqneg Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x3b, 0x22,
	// sqneg Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x3b, 0x2a,

	8,
	// sqrdmlah Hd, Hn, Vm.H[i]  ····························································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x3b, 0x32,
	// sqrdmlah Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x3b, 0x3c,
	// sqrdmlah Vd.8H, Vn.8H, Vm.H[i]  ······················································  (m < 16)
	// sqrdmlah Vd.4H, Vn.4H, Vm.H[i]  ······················································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x3b, 0x46,
	// sqrdmlah Vd.4S, Vn.4S, Vm.S[i]
	// sqrdmlah Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x3b, 0x51,
	// sqrdmlah Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3b, 0x5c,
	// sqrdmlah Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3b, 0x64,
	// sqrdmlah Vd.8H, Vn.8H, Vm.8H
	// sqrdmlah Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3b, 0x6c,
	// sqrdmlah Vd.4S, Vn.4S, Vm.4S
	// sqrdmlah Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3b, 0x75,

	8,
	// sqrdmlsh Hd, Hn, Vm.H[i]  ····························································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x3b, 0x7e,
	// sqrdmlsh Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x3b, 0x88,
	// sqrdmlsh Vd.8H, Vn.8H, Vm.H[i]  ······················································  (m < 16)
	// sqrdmlsh Vd.4H, Vn.4H, Vm.H[i]  ······················································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x3b, 0x92,
	// sqrdmlsh Vd.4S, Vn.4S, Vm.S[i]
	// sqrdmlsh Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x3b, 0x9d,
	// sqrdmlsh Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3b, 0xa8,
	// sqrdmlsh Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3b, 0xb0,
	// sqrdmlsh Vd.8H, Vn.8H, Vm.8H
	// sqrdmlsh Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3b, 0xb8,
	// sqrdmlsh Vd.4S, Vn.4S, Vm.4S
	// sqrdmlsh Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3b, 0xc1,

	8,
	// sqrdmulh Hd, Hn, Vm.H[i]  ····························································  (m < 16)
	3, MatH, MatH, MatVElement, byte(WORD), 0x3b, 0xca,
	// sqrdmulh Sd, Sn, Vm.S[i]
	3, MatS, MatS, MatVElement, byte(DWORD), 0x3b, 0xd4,
	// sqrdmulh Vd.8H, Vn.8H, Vm.H[i]  ······················································  (m < 16)
	// sqrdmulh Vd.4H, Vn.4H, Vm.H[i]  ······················································  (m < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatVElement, byte(WORD), 0x3b, 0xde,
	// sqrdmulh Vd.4S, Vn.4S, Vm.S[i]
	// sqrdmulh Vd.2S, Vn.2S, Vm.S[i]
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatVElement, byte(DWORD), 0x3b, 0xe9,
	// sqrdmulh Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3b, 0xf4,
	// sqrdmulh Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3b, 0xfc,
	// sqrdmulh Vd.8H, Vn.8H, Vm.8H
	// sqrdmulh Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3c, 0x4,
	// sqrdmulh Vd.4S, Vn.4S, Vm.4S
	// sqrdmulh Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3c, 0xd,

	8,
	// sqrshl Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x3c, 0x16,
	// sqrshl Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3c, 0x1e,
	// sqrshl Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3c, 0x26,
	// sqrshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x3c, 0x2e,
	// sqrshl Vd.16B, Vn.16B, Vm.16B
	// sqrshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3c, 0x36,
	// sqrshl Vd.8H, Vn.8H, Vm.8H
	// sqrshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3c, 0x3f,
	// sqrshl Vd.4S, Vn.4S, Vm.4S
	// sqrshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3c, 0x48,
	// sqrshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x3c, 0x51,

	6,
	// sqrshrn Bd, Hn, #imm  ··························································  (0 < imm <= 8)
	3, MatB, MatH, MatImm, 0x3c, 0x5a,
	// sqrshrn Hd, Sn, #imm  ·························································  (0 < imm <= 16)
	3, MatH, MatS, MatImm, 0x3c, 0x67,
	// sqrshrn Sd, Dn, #imm  ·························································  (0 < imm <= 32)
	3, MatS, MatD, MatImm, 0x3c, 0x74,
	// sqrshrn Vd.8B, Vn.8H, #imm  ····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x3c, 0x81,
	// sqrshrn Vd.4H, Vn.4S, #imm  ···················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x3c, 0x8c,
	// sqrshrn Vd.2S, Vn.2D, #imm  ···················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3c, 0x97,

	3,
	// sqrshrn2 Vd.16B, Vn.8H, #imm  ··················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x3c, 0xa2,
	// sqrshrn2 Vd.8H, Vn.4S, #imm  ··················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x3c, 0xad,
	// sqrshrn2 Vd.4S, Vn.2D, #imm  ··················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x3c, 0xb8,

	6,
	// sqrshrun Bd, Hn, #imm  ·························································  (0 < imm <= 8)
	3, MatB, MatH, MatImm, 0x3c, 0xc3,
	// sqrshrun Hd, Sn, #imm  ························································  (0 < imm <= 16)
	3, MatH, MatS, MatImm, 0x3c, 0xd0,
	// sqrshrun Sd, Dn, #imm  ························································  (0 < imm <= 32)
	3, MatS, MatD, MatImm, 0x3c, 0xdd,
	// sqrshrun Vd.8B, Vn.8H, #imm  ···················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x3c, 0xea,
	// sqrshrun Vd.4H, Vn.4S, #imm  ··················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x3c, 0xf5,
	// sqrshrun Vd.2S, Vn.2D, #imm  ··················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3d, 0x0,

	3,
	// sqrshrun2 Vd.16B, Vn.8H, #imm  ·················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x3d, 0xb,
	// sqrshrun2 Vd.8H, Vn.4S, #imm  ·················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x3d, 0x16,
	// sqrshrun2 Vd.4S, Vn.2D, #imm  ·················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x3d, 0x21,

	16,
	// sqshl Bd, Bn, #imm  ····························································  (0 <= imm < 8)
	3, MatB, MatB, MatImm, 0x3d, 0x2c,
	// sqshl Hd, Hn, #imm  ···························································  (0 <= imm < 16)
	3, MatH, MatH, MatImm, 0x3d, 0x36,
	// sqshl Sd, Sn, #imm  ···························································  (0 <= imm < 32)
	3, MatS, MatS, MatImm, 0x3d, 0x40,
	// sqshl Dd, Dn, #imm  ···························································  (0 <= imm < 64)
	3, MatD, MatD, MatImm, 0x3d, 0x4a,
	// sqshl Vd.16B, Vn.16B, #imm  ····················································  (0 <= imm < 8)
	// sqshl Vd.8B, Vn.8B, #imm  ······················································  (0 <= imm < 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x3d, 0x54,
	// sqshl Vd.8H, Vn.8H, #imm  ·····················································  (0 <= imm < 16)
	// sqshl Vd.4H, Vn.4H, #imm  ·····················································  (0 <= imm < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x3d, 0x5f,
	// sqshl Vd.4S, Vn.4S, #imm  ·····················································  (0 <= imm < 32)
	// sqshl Vd.2S, Vn.2S, #imm  ·····················································  (0 <= imm < 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x3d, 0x6a,
	// sqshl Vd.2D, Vn.2D, #imm  ·····················································  (0 <= imm < 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3d, 0x75,
	// sqshl Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x3d, 0x80,
	// sqshl Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3d, 0x88,
	// sqshl Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3d, 0x90,
	// sqshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x3d, 0x98,
	// sqshl Vd.16B, Vn.16B, Vm.16B
	// sqshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3d, 0xa0,
	// sqshl Vd.8H, Vn.8H, Vm.8H
	// sqshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3d, 0xa9,
	// sqshl Vd.4S, Vn.4S, Vm.4S
	// sqshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3d, 0xb2,
	// sqshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x3d, 0xbb,

	8,
	// sqshlu Bd, Bn, #imm  ···························································  (0 <= imm < 8)
	3, MatB, MatB, MatImm, 0x3d, 0xc4,
	// sqshlu Hd, Hn, #imm  ··························································  (0 <= imm < 16)
	3, MatH, MatH, MatImm, 0x3d, 0xce,
	// sqshlu Sd, Sn, #imm  ··························································  (0 <= imm < 32)
	3, MatS, MatS, MatImm, 0x3d, 0xd8,
	// sqshlu Dd, Dn, #imm  ··························································  (0 <= imm < 64)
	3, MatD, MatD, MatImm, 0x3d, 0xe2,
	// sqshlu Vd.16B, Vn.16B, #imm  ···················································  (0 <= imm < 8)
	// sqshlu Vd.8B, Vn.8B, #imm  ·····················································  (0 <= imm < 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x3d, 0xec,
	// sqshlu Vd.8H, Vn.8H, #imm  ····················································  (0 <= imm < 16)
	// sqshlu Vd.4H, Vn.4H, #imm  ····················································  (0 <= imm < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x3d, 0xf7,
	// sqshlu Vd.4S, Vn.4S, #imm  ····················································  (0 <= imm < 32)
	// sqshlu Vd.2S, Vn.2S, #imm  ····················································  (0 <= imm < 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x3e, 0x2,
	// sqshlu Vd.2D, Vn.2D, #imm  ····················································  (0 <= imm < 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3e, 0xd,

	6,
	// sqshrn Bd, Hn, #imm  ···························································  (0 < imm <= 8)
	3, MatB, MatH, MatImm, 0x3e, 0x18,
	// sqshrn Hd, Sn, #imm  ··························································  (0 < imm <= 16)
	3, MatH, MatS, MatImm, 0x3e, 0x25,
	// sqshrn Sd, Dn, #imm  ··························································  (0 < imm <= 32)
	3, MatS, MatD, MatImm, 0x3e, 0x32,
	// sqshrn Vd.8B, Vn.8H, #imm  ·····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x3e, 0x3f,
	// sqshrn Vd.4H, Vn.4S, #imm  ····················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x3e, 0x4a,
	// sqshrn Vd.2S, Vn.2D, #imm  ····················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3e, 0x55,

	3,
	// sqshrn2 Vd.16B, Vn.8H, #imm  ···················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x3e, 0x60,
	// sqshrn2 Vd.8H, Vn.4S, #imm  ···················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x3e, 0x6b,
	// sqshrn2 Vd.4S, Vn.2D, #imm  ···················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x3e, 0x76,

	6,
	// sqshrun Bd, Hn, #imm  ··························································  (0 < imm <= 8)
	3, MatB, MatH, MatImm, 0x3e, 0x81,
	// sqshrun Hd, Sn, #imm  ·························································  (0 < imm <= 16)
	3, MatH, MatS, MatImm, 0x3e, 0x8e,
	// sqshrun Sd, Dn, #imm  ·························································  (0 < imm <= 32)
	3, MatS, MatD, MatImm, 0x3e, 0x9b,
	// sqshrun Vd.8B, Vn.8H, #imm  ····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x3e, 0xa8,
	// sqshrun Vd.4H, Vn.4S, #imm  ···················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x3e, 0xb3,
	// sqshrun Vd.2S, Vn.2D, #imm  ···················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3e, 0xbe,

	3,
	// sqshrun2 Vd.16B, Vn.8H, #imm  ··················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x3e, 0xc9,
	// sqshrun2 Vd.8H, Vn.4S, #imm  ··················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x3e, 0xd4,
	// sqshrun2 Vd.4S, Vn.2D, #imm  ··················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x3e, 0xdf,

	8,
	// sqsub Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x3e, 0xea,
	// sqsub Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x3e, 0xf2,
	// sqsub Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x3e, 0xfa,
	// sqsub Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x3f, 0x2,
	// sqsub Vd.16B, Vn.16B, Vm.16B
	// sqsub Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3f, 0xa,
	// sqsub Vd.8H, Vn.8H, Vm.8H
	// sqsub Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3f, 0x13,
	// sqsub Vd.4S, Vn.4S, Vm.4S
	// sqsub Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3f, 0x1c,
	// sqsub Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x3f, 0x25,

	6,
	// sqxtn Bd, Hn
	2, MatB, MatH, 0x3f, 0x2e,
	// sqxtn Hd, Sn
	2, MatH, MatS, 0x3f, 0x35,
	// sqxtn Sd, Dn
	2, MatS, MatD, 0x3f, 0x3c,
	// sqxtn Vd.8B, Vn.8H
	2, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, 0x3f, 0x43,
	// sqxtn Vd.4H, Vn.4S
	2, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, 0x3f, 0x4a,
	// sqxtn Vd.2S, Vn.2D
	2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, 0x3f, 0x51,

	3,
	// sqxtn2 Vd.16B, Vn.8H
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, 0x3f, 0x58,
	// sqxtn2 Vd.8H, Vn.4S
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, 0x3f, 0x5f,
	// sqxtn2 Vd.4S, Vn.2D
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, 0x3f, 0x66,

	6,
	// sqxtun Bd, Hn
	2, MatB, MatH, 0x3f, 0x6d,
	// sqxtun Hd, Sn
	2, MatH, MatS, 0x3f, 0x74,
	// sqxtun Sd, Dn
	2, MatS, MatD, 0x3f, 0x7b,
	// sqxtun Vd.8B, Vn.8H
	2, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, 0x3f, 0x82,
	// sqxtun Vd.4H, Vn.4S
	2, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, 0x3f, 0x89,
	// sqxtun Vd.2S, Vn.2D
	2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, 0x3f, 0x90,

	3,
	// sqxtun2 Vd.16B, Vn.8H
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, 0x3f, 0x97,
	// sqxtun2 Vd.8H, Vn.4S
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, 0x3f, 0x9e,
	// sqxtun2 Vd.4S, Vn.2D
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, 0x3f, 0xa5,

	3,
	// srhadd Vd.16B, Vn.16B, Vm.16B
	// srhadd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x3f, 0xac,
	// srhadd Vd.8H, Vn.8H, Vm.8H
	// srhadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x3f, 0xb5,
	// srhadd Vd.4S, Vn.4S, Vm.4S
	// srhadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x3f, 0xbe,

	5,
	// sri Dd, Dn, #imm  ·····························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x3f, 0xc7,
	// sri Vd.16B, Vn.16B, #imm  ······················································  (0 < imm <= 8)
	// sri Vd.8B, Vn.8B, #imm  ························································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x3f, 0xd4,
	// sri Vd.8H, Vn.8H, #imm  ·······················································  (0 < imm <= 16)
	// sri Vd.4H, Vn.4H, #imm  ·······················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x3f, 0xe0,
	// sri Vd.4S, Vn.4S, #imm  ·······················································  (0 < imm <= 32)
	// sri Vd.2S, Vn.2S, #imm  ·······················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x3f, 0xec,
	// sri Vd.2D, Vn.2D, #imm  ·······················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x3f, 0xf8,

	5,
	// srshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x40, 0x4,
	// srshl Vd.16B, Vn.16B, Vm.16B
	// srshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x40, 0xc,
	// srshl Vd.8H, Vn.8H, Vm.8H
	// srshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x40, 0x15,
	// srshl Vd.4S, Vn.4S, Vm.4S
	// srshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x40, 0x1e,
	// srshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x40, 0x27,

	5,
	// srshr Dd, Dn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x40, 0x30,
	// srshr Vd.16B, Vn.16B, #imm  ····················································  (0 < imm <= 8)
	// srshr Vd.8B, Vn.8B, #imm  ······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x40, 0x3d,
	// srshr Vd.8H, Vn.8H, #imm  ·····················································  (0 < imm <= 16)
	// srshr Vd.4H, Vn.4H, #imm  ·····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x40, 0x49,
	// srshr Vd.4S, Vn.4S, #imm  ·····················································  (0 < imm <= 32)
	// srshr Vd.2S, Vn.2S, #imm  ·····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x40, 0x55,
	// srshr Vd.2D, Vn.2D, #imm  ·····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x40, 0x61,

	5,
	// srsra Dd, Dn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x40, 0x6d,
	// srsra Vd.16B, Vn.16B, #imm  ····················································  (0 < imm <= 8)
	// srsra Vd.8B, Vn.8B, #imm  ······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x40, 0x7a,
	// srsra Vd.8H, Vn.8H, #imm  ·····················································  (0 < imm <= 16)
	// srsra Vd.4H, Vn.4H, #imm  ·····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x40, 0x86,
	// srsra Vd.4S, Vn.4S, #imm  ·····················································  (0 < imm <= 32)
	// srsra Vd.2S, Vn.2S, #imm  ·····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x40, 0x92,
	// srsra Vd.2D, Vn.2D, #imm  ·····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x40, 0x9e,

	1,
	// ssbb
	0, 0x40, 0xaa,

	5,
	// sshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x40, 0xaf,
	// sshl Vd.16B, Vn.16B, Vm.16B
	// sshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x40, 0xb7,
	// sshl Vd.8H, Vn.8H, Vm.8H
	// sshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x40, 0xc0,
	// sshl Vd.4S, Vn.4S, Vm.4S
	// sshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x40, 0xc9,
	// sshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x40, 0xd2,

	3,
	// sshll Vd.8H, Vn.8B, #imm  ······················································  (0 <= imm < 8)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatImm, 0x40, 0xdb,
	// sshll Vd.4S, Vn.4H, #imm  ·····················································  (0 <= imm < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatImm, 0x40, 0xe5,
	// sshll Vd.2D, Vn.2S, #imm  ·····················································  (0 <= imm < 32)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatImm, 0x40, 0xef,

	3,
	// sshll2 Vd.8H, Vn.16B, #imm  ····················································  (0 <= imm < 8)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatImm, 0x40, 0xf9,
	// sshll2 Vd.4S, Vn.8H, #imm  ····················································  (0 <= imm < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatImm, 0x41, 0x3,
	// sshll2 Vd.2D, Vn.4S, #imm  ····················································  (0 <= imm < 32)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatImm, 0x41, 0xd,

	5,
	// sshr Dd, Dn, #imm  ····························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x41, 0x17,
	// sshr Vd.16B, Vn.16B, #imm  ·····················································  (0 < imm <= 8)
	// sshr Vd.8B, Vn.8B, #imm  ·······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x41, 0x24,
	// sshr Vd.8H, Vn.8H, #imm  ······················································  (0 < imm <= 16)
	// sshr Vd.4H, Vn.4H, #imm  ······················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x41, 0x30,
	// sshr Vd.4S, Vn.4S, #imm  ······················································  (0 < imm <= 32)
	// sshr Vd.2S, Vn.2S, #imm  ······················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x41, 0x3c,
	// sshr Vd.2D, Vn.2D, #imm  ······················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x41, 0x48,

	5,
	// ssra Dd, Dn, #imm  ····························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x41, 0x54,
	// ssra Vd.16B, Vn.16B, #imm  ·····················································  (0 < imm <= 8)
	// ssra Vd.8B, Vn.8B, #imm  ·······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x41, 0x61,
	// ssra Vd.8H, Vn.8H, #imm  ······················································  (0 < imm <= 16)
	// ssra Vd.4H, Vn.4H, #imm  ······················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x41, 0x6d,
	// ssra Vd.4S, Vn.4S, #imm  ······················································  (0 < imm <= 32)
	// ssra Vd.2S, Vn.2S, #imm  ······················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x41, 0x79,
	// ssra Vd.2D, Vn.2D, #imm  ······················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x41, 0x85,

	3,
	// ssubl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x41, 0x91,
	// ssubl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x41, 0x99,
	// ssubl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x41, 0xa1,

	3,
	// ssubl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x41, 0xa9,
	// ssubl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x41, 0xb1,
	// ssubl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x41, 0xb9,

	3,
	// ssubw Vd.8H, Vn.8H, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, 0x41, 0xc1,
	// ssubw Vd.4S, Vn.4S, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0x41, 0xc9,
	// ssubw Vd.2D, Vn.2D, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0x41, 0xd1,

	3,
	// ssubw2 Vd.8H, Vn.8H, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, 0x41, 0xd9,
	// ssubw2 Vd.4S, Vn.4S, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0x41, 0xe1,
	// ssubw2 Vd.2D, Vn.2D, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0x41, 0xe9,

	76,
	// st1 {Vd.16B * 1}, [Xn|SP]
	// st1 {Vd.8B * 1}, [Xn|SP]
	2, MatRegList, 1, byte(BYTE), MatRefBase, 0x41, 0xf1,
	// st1 {Vd.8H * 1}, [Xn|SP]
	// st1 {Vd.4H * 1}, [Xn|SP]
	2, MatRegList, 1, byte(WORD), MatRefBase, 0x41, 0xf9,
	// st1 {Vd.4S * 1}, [Xn|SP]
	// st1 {Vd.2S * 1}, [Xn|SP]
	2, MatRegList, 1, byte(DWORD), MatRefBase, 0x42, 0x1,
	// st1 {Vd.2D * 1}, [Xn|SP]
	// st1 {Vd.1D * 1}, [Xn|SP]
	2, MatRegList, 1, byte(QWORD), MatRefBase, 0x42, 0x9,
	// st1 {Vd.16B * 2}, [Xn|SP]
	// st1 {Vd.8B * 2}, [Xn|SP]
	2, MatRegList, 2, byte(BYTE), MatRefBase, 0x42, 0x11,
	// st1 {Vd.8H * 2}, [Xn|SP]
	// st1 {Vd.4H * 2}, [Xn|SP]
	2, MatRegList, 2, byte(WORD), MatRefBase, 0x42, 0x19,
	// st1 {Vd.4S * 2}, [Xn|SP]
	// st1 {Vd.2S * 2}, [Xn|SP]
	2, MatRegList, 2, byte(DWORD), MatRefBase, 0x42, 0x21,
	// st1 {Vd.2D * 2}, [Xn|SP]
	// st1 {Vd.1D * 2}, [Xn|SP]
	2, MatRegList, 2, byte(QWORD), MatRefBase, 0x42, 0x29,
	// st1 {Vd.16B * 3}, [Xn|SP]
	// st1 {Vd.8B * 3}, [Xn|SP]
	2, MatRegList, 3, byte(BYTE), MatRefBase, 0x42, 0x31,
	// st1 {Vd.8H * 3}, [Xn|SP]
	// st1 {Vd.4H * 3}, [Xn|SP]
	2, MatRegList, 3, byte(WORD), MatRefBase, 0x42, 0x39,
	// st1 {Vd.4S * 3}, [Xn|SP]
	// st1 {Vd.2S * 3}, [Xn|SP]
	2, MatRegList, 3, byte(DWORD), MatRefBase, 0x42, 0x41,
	// st1 {Vd.2D * 3}, [Xn|SP]
	// st1 {Vd.1D * 3}, [Xn|SP]
	2, MatRegList, 3, byte(QWORD), MatRefBase, 0x42, 0x49,
	// st1 {Vd.16B * 4}, [Xn|SP]
	// st1 {Vd.8B * 4}, [Xn|SP]
	2, MatRegList, 4, byte(BYTE), MatRefBase, 0x42, 0x51,
	// st1 {Vd.8H * 4}, [Xn|SP]
	// st1 {Vd.4H * 4}, [Xn|SP]
	2, MatRegList, 4, byte(WORD), MatRefBase, 0x42, 0x59,
	// st1 {Vd.4S * 4}, [Xn|SP]
	// st1 {Vd.2S * 4}, [Xn|SP]
	2, MatRegList, 4, byte(DWORD), MatRefBase, 0x42, 0x61,
	// st1 {Vd.2D * 4}, [Xn|SP]
	// st1 {Vd.1D * 4}, [Xn|SP]
	2, MatRegList, 4, byte(QWORD), MatRefBase, 0x42, 0x69,
	// st1 {Vd.8B * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(BYTE), 8, MatRefBase, MatLitInt, 8, 0x42, 0x71,
	// st1 {Vd.4H * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(WORD), 4, MatRefBase, MatLitInt, 8, 0x42, 0x78,
	// st1 {Vd.2S * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(DWORD), 2, MatRefBase, MatLitInt, 8, 0x42, 0x7f,
	// st1 {Vd.1D * 1}, [Xn|SP], #8
	3, MatRegListStatic, 1, byte(QWORD), 1, MatRefBase, MatLitInt, 8, 0x42, 0x86,
	// st1 {Vd.16B * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(BYTE), 16, MatRefBase, MatLitInt, 16, 0x42, 0x8d,
	// st1 {Vd.8H * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(WORD), 8, MatRefBase, MatLitInt, 16, 0x42, 0x94,
	// st1 {Vd.4S * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(DWORD), 4, MatRefBase, MatLitInt, 16, 0x42, 0x9b,
	// st1 {Vd.2D * 1}, [Xn|SP], #16
	3, MatRegListStatic, 1, byte(QWORD), 2, MatRefBase, MatLitInt, 16, 0x42, 0xa2,
	// st1 {Vd.16B * 1}, [Xn|SP], Xm  ······················································  (m != 31)
	// st1 {Vd.8B * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(BYTE), MatRefBase, MatX, 0x42, 0xa9,
	// st1 {Vd.8H * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.4H * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(WORD), MatRefBase, MatX, 0x42, 0xb2,
	// st1 {Vd.4S * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.2S * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(DWORD), MatRefBase, MatX, 0x42, 0xbb,
	// st1 {Vd.2D * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.1D * 1}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 1, byte(QWORD), MatRefBase, MatX, 0x42, 0xc4,
	// st1 {Vd.8B * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(BYTE), 8, MatRefBase, MatLitInt, 16, 0x42, 0xcd,
	// st1 {Vd.4H * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(WORD), 4, MatRefBase, MatLitInt, 16, 0x42, 0xd4,
	// st1 {Vd.2S * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(DWORD), 2, MatRefBase, MatLitInt, 16, 0x42, 0xdb,
	// st1 {Vd.1D * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(QWORD), 1, MatRefBase, MatLitInt, 16, 0x42, 0xe2,
	// st1 {Vd.16B * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(BYTE), 16, MatRefBase, MatLitInt, 32, 0x42, 0xe9,
	// st1 {Vd.8H * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(WORD), 8, MatRefBase, MatLitInt, 32, 0x42, 0xf0,
	// st1 {Vd.4S * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(DWORD), 4, MatRefBase, MatLitInt, 32, 0x42, 0xf7,
	// st1 {Vd.2D * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, MatLitInt, 32, 0x42, 0xfe,
	// st1 {Vd.16B * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// st1 {Vd.8B * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(BYTE), MatRefBase, MatX, 0x43, 0x5,
	// st1 {Vd.8H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.4H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(WORD), MatRefBase, MatX, 0x43, 0xe,
	// st1 {Vd.4S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.2S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(DWORD), MatRefBase, MatX, 0x43, 0x17,
	// st1 {Vd.2D * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.1D * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(QWORD), MatRefBase, MatX, 0x43, 0x20,
	// st1 {Vd.8B * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(BYTE), 8, MatRefBase, MatLitInt, 24, 0x43, 0x29,
	// st1 {Vd.4H * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(WORD), 4, MatRefBase, MatLitInt, 24, 0x43, 0x30,
	// st1 {Vd.2S * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(DWORD), 2, MatRefBase, MatLitInt, 24, 0x43, 0x37,
	// st1 {Vd.1D * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(QWORD), 1, MatRefBase, MatLitInt, 24, 0x43, 0x3e,
	// st1 {Vd.16B * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(BYTE), 16, MatRefBase, MatLitInt, 48, 0x43, 0x45,
	// st1 {Vd.8H * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(WORD), 8, MatRefBase, MatLitInt, 48, 0x43, 0x4c,
	// st1 {Vd.4S * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(DWORD), 4, MatRefBase, MatLitInt, 48, 0x43, 0x53,
	// st1 {Vd.2D * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, MatLitInt, 48, 0x43, 0x5a,
	// st1 {Vd.16B * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// st1 {Vd.8B * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(BYTE), MatRefBase, MatX, 0x43, 0x61,
	// st1 {Vd.8H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.4H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(WORD), MatRefBase, MatX, 0x43, 0x6a,
	// st1 {Vd.4S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.2S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(DWORD), MatRefBase, MatX, 0x43, 0x73,
	// st1 {Vd.2D * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.1D * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(QWORD), MatRefBase, MatX, 0x43, 0x7c,
	// st1 {Vd.8B * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(BYTE), 8, MatRefBase, MatLitInt, 32, 0x43, 0x85,
	// st1 {Vd.4H * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(WORD), 4, MatRefBase, MatLitInt, 32, 0x43, 0x8c,
	// st1 {Vd.2S * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(DWORD), 2, MatRefBase, MatLitInt, 32, 0x43, 0x93,
	// st1 {Vd.1D * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(QWORD), 1, MatRefBase, MatLitInt, 32, 0x43, 0x9a,
	// st1 {Vd.16B * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(BYTE), 16, MatRefBase, MatLitInt, 64, 0x43, 0xa1,
	// st1 {Vd.8H * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(WORD), 8, MatRefBase, MatLitInt, 64, 0x43, 0xa8,
	// st1 {Vd.4S * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(DWORD), 4, MatRefBase, MatLitInt, 64, 0x43, 0xaf,
	// st1 {Vd.2D * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, MatLitInt, 64, 0x43, 0xb6,
	// st1 {Vd.16B * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// st1 {Vd.8B * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(BYTE), MatRefBase, MatX, 0x43, 0xbd,
	// st1 {Vd.8H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.4H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(WORD), MatRefBase, MatX, 0x43, 0xc6,
	// st1 {Vd.4S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.2S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(DWORD), MatRefBase, MatX, 0x43, 0xcf,
	// st1 {Vd.2D * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st1 {Vd.1D * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(QWORD), MatRefBase, MatX, 0x43, 0xd8,
	// st1 {Vd.B * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(BYTE), MatRefBase, 0x43, 0xe1,
	// st1 {Vd.H * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(WORD), MatRefBase, 0x43, 0xea,
	// st1 {Vd.S * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(DWORD), MatRefBase, 0x43, 0xf3,
	// st1 {Vd.D * 1}[i], [Xn|SP]
	2, MatRegListElement, 1, byte(QWORD), MatRefBase, 0x43, 0xfc,
	// st1 {Vd.B * 1}[i], [Xn|SP], #1
	3, MatRegListElement, 1, byte(BYTE), MatRefBase, MatLitInt, 1, 0x44, 0x5,
	// st1 {Vd.B * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(BYTE), MatRefBase, MatX, 0x44, 0xe,
	// st1 {Vd.H * 1}[i], [Xn|SP], #2
	3, MatRegListElement, 1, byte(WORD), MatRefBase, MatLitInt, 2, 0x44, 0x18,
	// st1 {Vd.H * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(WORD), MatRefBase, MatX, 0x44, 0x21,
	// st1 {Vd.S * 1}[i], [Xn|SP], #4
	3, MatRegListElement, 1, byte(DWORD), MatRefBase, MatLitInt, 4, 0x44, 0x2b,
	// st1 {Vd.S * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(DWORD), MatRefBase, MatX, 0x44, 0x34,
	// st1 {Vd.D * 1}[i], [Xn|SP], #8
	3, MatRegListElement, 1, byte(QWORD), MatRefBase, MatLitInt, 8, 0x44, 0x3e,
	// st1 {Vd.D * 1}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 1, byte(QWORD), MatRefBase, MatX, 0x44, 0x47,

	27,
	// st2 {Vd.16B * 2}, [Xn|SP]
	// st2 {Vd.8B * 2}, [Xn|SP]
	2, MatRegList, 2, byte(BYTE), MatRefBase, 0x44, 0x51,
	// st2 {Vd.8H * 2}, [Xn|SP]
	// st2 {Vd.4H * 2}, [Xn|SP]
	2, MatRegList, 2, byte(WORD), MatRefBase, 0x44, 0x59,
	// st2 {Vd.4S * 2}, [Xn|SP]
	// st2 {Vd.2S * 2}, [Xn|SP]
	2, MatRegList, 2, byte(DWORD), MatRefBase, 0x44, 0x61,
	// st2 {Vd.2D * 2}, [Xn|SP]
	2, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, 0x44, 0x69,
	// st2 {Vd.8B * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(BYTE), 8, MatRefBase, MatLitInt, 16, 0x44, 0x71,
	// st2 {Vd.4H * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(WORD), 4, MatRefBase, MatLitInt, 16, 0x44, 0x78,
	// st2 {Vd.2S * 2}, [Xn|SP], #16
	3, MatRegListStatic, 2, byte(DWORD), 2, MatRefBase, MatLitInt, 16, 0x44, 0x7f,
	// st2 {Vd.16B * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(BYTE), 16, MatRefBase, MatLitInt, 32, 0x44, 0x86,
	// st2 {Vd.8H * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(WORD), 8, MatRefBase, MatLitInt, 32, 0x44, 0x8d,
	// st2 {Vd.4S * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(DWORD), 4, MatRefBase, MatLitInt, 32, 0x44, 0x94,
	// st2 {Vd.2D * 2}, [Xn|SP], #32
	3, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, MatLitInt, 32, 0x44, 0x9b,
	// st2 {Vd.16B * 2}, [Xn|SP], Xm  ······················································  (m != 31)
	// st2 {Vd.8B * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(BYTE), MatRefBase, MatX, 0x44, 0xa2,
	// st2 {Vd.8H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st2 {Vd.4H * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(WORD), MatRefBase, MatX, 0x44, 0xab,
	// st2 {Vd.4S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st2 {Vd.2S * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 2, byte(DWORD), MatRefBase, MatX, 0x44, 0xb4,
	// st2 {Vd.2D * 2}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegListStatic, 2, byte(QWORD), 2, MatRefBase, MatX, 0x44, 0xbd,
	// st2 {Vd.B * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(BYTE), MatRefBase, 0x44, 0xc6,
	// st2 {Vd.H * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(WORD), MatRefBase, 0x44, 0xcf,
	// st2 {Vd.S * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(DWORD), MatRefBase, 0x44, 0xd8,
	// st2 {Vd.D * 2}[i], [Xn|SP]
	2, MatRegListElement, 2, byte(QWORD), MatRefBase, 0x44, 0xe1,
	// st2 {Vd.B * 2}[i], [Xn|SP], #2
	3, MatRegListElement, 2, byte(BYTE), MatRefBase, MatLitInt, 2, 0x44, 0xea,
	// st2 {Vd.B * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(BYTE), MatRefBase, MatX, 0x44, 0xf3,
	// st2 {Vd.H * 2}[i], [Xn|SP], #4
	3, MatRegListElement, 2, byte(WORD), MatRefBase, MatLitInt, 4, 0x44, 0xfd,
	// st2 {Vd.H * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(WORD), MatRefBase, MatX, 0x45, 0x6,
	// st2 {Vd.S * 2}[i], [Xn|SP], #8
	3, MatRegListElement, 2, byte(DWORD), MatRefBase, MatLitInt, 8, 0x45, 0x10,
	// st2 {Vd.S * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(DWORD), MatRefBase, MatX, 0x45, 0x19,
	// st2 {Vd.D * 2}[i], [Xn|SP], #16
	3, MatRegListElement, 2, byte(QWORD), MatRefBase, MatLitInt, 16, 0x45, 0x23,
	// st2 {Vd.D * 2}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 2, byte(QWORD), MatRefBase, MatX, 0x45, 0x2c,

	27,
	// st3 {Vd.16B * 3}, [Xn|SP]
	// st3 {Vd.8B * 3}, [Xn|SP]
	2, MatRegList, 3, byte(BYTE), MatRefBase, 0x45, 0x36,
	// st3 {Vd.8H * 3}, [Xn|SP]
	// st3 {Vd.4H * 3}, [Xn|SP]
	2, MatRegList, 3, byte(WORD), MatRefBase, 0x45, 0x3e,
	// st3 {Vd.4S * 3}, [Xn|SP]
	// st3 {Vd.2S * 3}, [Xn|SP]
	2, MatRegList, 3, byte(DWORD), MatRefBase, 0x45, 0x46,
	// st3 {Vd.2D * 3}, [Xn|SP]
	2, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, 0x45, 0x4e,
	// st3 {Vd.8B * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(BYTE), 8, MatRefBase, MatLitInt, 24, 0x45, 0x56,
	// st3 {Vd.4H * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(WORD), 4, MatRefBase, MatLitInt, 24, 0x45, 0x5d,
	// st3 {Vd.2S * 3}, [Xn|SP], #24
	3, MatRegListStatic, 3, byte(DWORD), 2, MatRefBase, MatLitInt, 24, 0x45, 0x64,
	// st3 {Vd.16B * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(BYTE), 16, MatRefBase, MatLitInt, 48, 0x45, 0x6b,
	// st3 {Vd.8H * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(WORD), 8, MatRefBase, MatLitInt, 48, 0x45, 0x72,
	// st3 {Vd.4S * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(DWORD), 4, MatRefBase, MatLitInt, 48, 0x45, 0x79,
	// st3 {Vd.2D * 3}, [Xn|SP], #48
	3, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, MatLitInt, 48, 0x45, 0x80,
	// st3 {Vd.16B * 3}, [Xn|SP], Xm  ······················································  (m != 31)
	// st3 {Vd.8B * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(BYTE), MatRefBase, MatX, 0x45, 0x87,
	// st3 {Vd.8H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st3 {Vd.4H * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(WORD), MatRefBase, MatX, 0x45, 0x90,
	// st3 {Vd.4S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st3 {Vd.2S * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 3, byte(DWORD), MatRefBase, MatX, 0x45, 0x99,
	// st3 {Vd.2D * 3}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegListStatic, 3, byte(QWORD), 2, MatRefBase, MatX, 0x45, 0xa2,
	// st3 {Vd.B * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(BYTE), MatRefBase, 0x45, 0xab,
	// st3 {Vd.H * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(WORD), MatRefBase, 0x45, 0xb4,
	// st3 {Vd.S * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(DWORD), MatRefBase, 0x45, 0xbd,
	// st3 {Vd.D * 3}[i], [Xn|SP]
	2, MatRegListElement, 3, byte(QWORD), MatRefBase, 0x45, 0xc6,
	// st3 {Vd.B * 3}[i], [Xn|SP], #3
	3, MatRegListElement, 3, byte(BYTE), MatRefBase, MatLitInt, 3, 0x45, 0xcf,
	// st3 {Vd.B * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(BYTE), MatRefBase, MatX, 0x45, 0xd8,
	// st3 {Vd.H * 3}[i], [Xn|SP], #6
	3, MatRegListElement, 3, byte(WORD), MatRefBase, MatLitInt, 6, 0x45, 0xe2,
	// st3 {Vd.H * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(WORD), MatRefBase, MatX, 0x45, 0xeb,
	// st3 {Vd.S * 3}[i], [Xn|SP], #12
	3, MatRegListElement, 3, byte(DWORD), MatRefBase, MatLitInt, 12, 0x45, 0xf5,
	// st3 {Vd.S * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(DWORD), MatRefBase, MatX, 0x45, 0xfe,
	// st3 {Vd.D * 3}[i], [Xn|SP], #24
	3, MatRegListElement, 3, byte(QWORD), MatRefBase, MatLitInt, 24, 0x46, 0x8,
	// st3 {Vd.D * 3}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 3, byte(QWORD), MatRefBase, MatX, 0x46, 0x11,

	27,
	// st4 {Vd.16B * 4}, [Xn|SP]
	// st4 {Vd.8B * 4}, [Xn|SP]
	2, MatRegList, 4, byte(BYTE), MatRefBase, 0x46, 0x1b,
	// st4 {Vd.8H * 4}, [Xn|SP]
	// st4 {Vd.4H * 4}, [Xn|SP]
	2, MatRegList, 4, byte(WORD), MatRefBase, 0x46, 0x23,
	// st4 {Vd.4S * 4}, [Xn|SP]
	// st4 {Vd.2S * 4}, [Xn|SP]
	2, MatRegList, 4, byte(DWORD), MatRefBase, 0x46, 0x2b,
	// st4 {Vd.2D * 4}, [Xn|SP]
	2, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, 0x46, 0x33,
	// st4 {Vd.8B * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(BYTE), 8, MatRefBase, MatLitInt, 32, 0x46, 0x3b,
	// st4 {Vd.4H * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(WORD), 4, MatRefBase, MatLitInt, 32, 0x46, 0x42,
	// st4 {Vd.2S * 4}, [Xn|SP], #32
	3, MatRegListStatic, 4, byte(DWORD), 2, MatRefBase, MatLitInt, 32, 0x46, 0x49,
	// st4 {Vd.16B * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(BYTE), 16, MatRefBase, MatLitInt, 64, 0x46, 0x50,
	// st4 {Vd.8H * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(WORD), 8, MatRefBase, MatLitInt, 64, 0x46, 0x57,
	// st4 {Vd.4S * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(DWORD), 4, MatRefBase, MatLitInt, 64, 0x46, 0x5e,
	// st4 {Vd.2D * 4}, [Xn|SP], #64
	3, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, MatLitInt, 64, 0x46, 0x65,
	// st4 {Vd.16B * 4}, [Xn|SP], Xm  ······················································  (m != 31)
	// st4 {Vd.8B * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(BYTE), MatRefBase, MatX, 0x46, 0x6c,
	// st4 {Vd.8H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st4 {Vd.4H * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(WORD), MatRefBase, MatX, 0x46, 0x75,
	// st4 {Vd.4S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	// st4 {Vd.2S * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegList, 4, byte(DWORD), MatRefBase, MatX, 0x46, 0x7e,
	// st4 {Vd.2D * 4}, [Xn|SP], Xm  ·······················································  (m != 31)
	3, MatRegListStatic, 4, byte(QWORD), 2, MatRefBase, MatX, 0x46, 0x87,
	// st4 {Vd.B * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(BYTE), MatRefBase, 0x46, 0x90,
	// st4 {Vd.H * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(WORD), MatRefBase, 0x46, 0x99,
	// st4 {Vd.S * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(DWORD), MatRefBase, 0x46, 0xa2,
	// st4 {Vd.D * 4}[i], [Xn|SP]
	2, MatRegListElement, 4, byte(QWORD), MatRefBase, 0x46, 0xab,
	// st4 {Vd.B * 4}[i], [Xn|SP], #4
	3, MatRegListElement, 4, byte(BYTE), MatRefBase, MatLitInt, 4, 0x46, 0xb4,
	// st4 {Vd.B * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(BYTE), MatRefBase, MatX, 0x46, 0xbd,
	// st4 {Vd.H * 4}[i], [Xn|SP], #8
	3, MatRegListElement, 4, byte(WORD), MatRefBase, MatLitInt, 8, 0x46, 0xc7,
	// st4 {Vd.H * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(WORD), MatRefBase, MatX, 0x46, 0xd0,
	// st4 {Vd.S * 4}[i], [Xn|SP], #16
	3, MatRegListElement, 4, byte(DWORD), MatRefBase, MatLitInt, 16, 0x46, 0xda,
	// st4 {Vd.S * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(DWORD), MatRefBase, MatX, 0x46, 0xe3,
	// st4 {Vd.D * 4}[i], [Xn|SP], #32
	3, MatRegListElement, 4, byte(QWORD), MatRefBase, MatLitInt, 32, 0x46, 0xed,
	// st4 {Vd.D * 4}[i], [Xn|SP], Xm  ·····················································  (m != 31)
	3, MatRegListElement, 4, byte(QWORD), MatRefBase, MatX, 0x46, 0xf6,

	2,
	// stadd Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x0,
	// stadd Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0x7,

	1,
	// staddb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xe,

	1,
	// staddh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x15,

	2,
	// staddl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x1c,
	// staddl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0x23,

	1,
	// staddlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x2a,

	1,
	// staddlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x31,

	2,
	// stclr Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x38,
	// stclr Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0x3f,

	1,
	// stclrb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x46,

	1,
	// stclrh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x4d,

	2,
	// stclrl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x54,
	// stclrl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0x5b,

	1,
	// stclrlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x62,

	1,
	// stclrlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x69,

	2,
	// steor Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x70,
	// steor Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0x77,

	1,
	// steorb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x7e,

	1,
	// steorh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x85,

	2,
	// steorl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x8c,
	// steorl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0x93,

	1,
	// steorlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0x9a,

	1,
	// steorlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xa1,

	2,
	// stllr Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xa8,
	// stllr Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0xaf,

	1,
	// stllrb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xb6,

	1,
	// stllrh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xbd,

	2,
	// stlr Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xc4,
	// stlr Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x47, 0xcb,

	1,
	// stlrb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xd2,

	1,
	// stlrh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x47, 0xd9,

	2,
	// stlur Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x47, 0xe0,
	// stlur Xd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x47, 0xe8,

	1,
	// stlurb Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x47, 0xf0,

	1,
	// stlurh Wd, [Xn|SP {, #imm }]  ·············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x47, 0xf8,

	2,
	// stlxp Wd, Wn, Wm, [Xa|SP]
	4, MatW, MatW, MatW, MatRefBase, 0x48, 0x0,
	// stlxp Wd, Xn, Xm, [Xa|SP]
	4, MatW, MatX, MatX, MatRefBase, 0x48, 0x9,

	2,
	// stlxr Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x48, 0x12,
	// stlxr Wd, Xn, [Xm|SP]
	3, MatW, MatX, MatRefBase, 0x48, 0x1a,

	1,
	// stlxrb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x48, 0x22,

	1,
	// stlxrh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x48, 0x2a,

	5,
	// stnp Sd, Sn, [Xm|SP {, #imm }]  ·································  (-256 <= imm < 256, imm >> 2)
	3, MatS, MatS, MatRefOffset, 0x48, 0x32,
	// stnp Dd, Dn, [Xm|SP {, #imm }]  ·································  (-512 <= imm < 512, imm >> 3)
	3, MatD, MatD, MatRefOffset, 0x48, 0x3c,
	// stnp Qd, Qn, [Xm|SP {, #imm }]  ·······························  (-1024 <= imm < 1024, imm >> 4)
	3, MatQ, MatQ, MatRefOffset, 0x48, 0x46,
	// stnp Wd, Wn, [Xm|SP {, #imm }]  ·································  (-256 <= imm < 256, imm >> 2)
	3, MatW, MatW, MatRefOffset, 0x48, 0x50,
	// stnp Xd, Xn, [Xm|SP {, #imm }]  ·································  (-512 <= imm < 512, imm >> 3)
	3, MatX, MatX, MatRefOffset, 0x48, 0x5a,

	15,
	// stp Sd, Sn, [Xm|SP], #imm  ······································  (-256 <= imm < 256, imm >> 2)
	4, MatS, MatS, MatRefBase, MatImm, 0x48, 0x64,
	// stp Dd, Dn, [Xm|SP], #imm  ······································  (-512 <= imm < 512, imm >> 3)
	4, MatD, MatD, MatRefBase, MatImm, 0x48, 0x6e,
	// stp Qd, Qn, [Xm|SP], #imm  ····································  (-1024 <= imm < 1024, imm >> 4)
	4, MatQ, MatQ, MatRefBase, MatImm, 0x48, 0x78,
	// stp Sd, Sn, [Xm|SP, #imm]!  ·····································  (-256 <= imm < 256, imm >> 2)
	3, MatS, MatS, MatRefPre, 0x48, 0x82,
	// stp Dd, Dn, [Xm|SP, #imm]!  ·····································  (-512 <= imm < 512, imm >> 3)
	3, MatD, MatD, MatRefPre, 0x48, 0x8c,
	// stp Qd, Qn, [Xm|SP, #imm]!  ···································  (-1024 <= imm < 1024, imm >> 4)
	3, MatQ, MatQ, MatRefPre, 0x48, 0x96,
	// stp Sd, Sn, [Xm|SP {, #imm }]  ··································  (-256 <= imm < 256, imm >> 2)
	3, MatS, MatS, MatRefOffset, 0x48, 0xa0,
	// stp Dd, Dn, [Xm|SP {, #imm }]  ··································  (-512 <= imm < 512, imm >> 3)
	3, MatD, MatD, MatRefOffset, 0x48, 0xaa,
	// stp Qd, Qn, [Xm|SP {, #imm }]  ································  (-1024 <= imm < 1024, imm >> 4)
	3, MatQ, MatQ, MatRefOffset, 0x48, 0xb4,
	// stp Wd, Wn, [Xm|SP], #imm  ······································  (-256 <= imm < 256, imm >> 2)
	4, MatW, MatW, MatRefBase, MatImm, 0x48, 0xbe,
	// stp Xd, Xn, [Xm|SP], #imm  ······································  (-512 <= imm < 512, imm >> 3)
	4, MatX, MatX, MatRefBase, MatImm, 0x48, 0xc8,
	// stp Wd, Wn, [Xm|SP, #imm]!  ·····································  (-256 <= imm < 256, imm >> 2)
	3, MatW, MatW, MatRefPre, 0x48, 0xd2,
	// stp Xd, Xn, [Xm|SP, #imm]!  ·····································  (-512 <= imm < 512, imm >> 3)
	3, MatX, MatX, MatRefPre, 0x48, 0xdc,
	// stp Wd, Wn, [Xm|SP {, #imm }]  ··································  (-256 <= imm < 256, imm >> 2)
	3, MatW, MatW, MatRefOffset, 0x48, 0xe6,
	// stp Xd, Xn, [Xm|SP {, #imm }]  ··································  (-512 <= imm < 512, imm >> 3)
	3, MatX, MatX, MatRefOffset, 0x48, 0xf0,

	28,
	// str Bd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatB, MatRefBase, MatImm, 0x48, 0xfa,
	// str Hd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatH, MatRefBase, MatImm, 0x49, 0x2,
	// str Sd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatS, MatRefBase, MatImm, 0x49, 0xa,
	// str Dd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatD, MatRefBase, MatImm, 0x49, 0x12,
	// str Qd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatQ, MatRefBase, MatImm, 0x49, 0x1a,
	// str Bd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatB, MatRefPre, 0x49, 0x22,
	// str Hd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatH, MatRefPre, 0x49, 0x2a,
	// str Sd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatS, MatRefPre, 0x49, 0x32,
	// str Dd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatD, MatRefPre, 0x49, 0x3a,
	// str Qd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatQ, MatRefPre, 0x49, 0x42,
	// str Bd, [Xn|SP {, #imm }]  ··················································  (0 <= imm < 4096)
	2, MatB, MatRefOffset, 0x49, 0x4a,
	// str Hd, [Xn|SP {, #imm }]  ········································  (0 <= imm < 8192, imm >> 1)
	2, MatH, MatRefOffset, 0x49, 0x54,
	// str Sd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 16384, imm >> 2)
	2, MatS, MatRefOffset, 0x49, 0x5f,
	// str Dd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 32768, imm >> 3)
	2, MatD, MatRefOffset, 0x49, 0x6a,
	// str Qd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 65536, imm >> 4)
	2, MatQ, MatRefOffset, 0x49, 0x75,
	// str Wd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x49, 0x80,
	// str Xd, [Xn|SP], #imm  ····················································  (-256 <= imm < 256)
	3, MatX, MatRefBase, MatImm, 0x49, 0x88,
	// str Wd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x49, 0x90,
	// str Xd, [Xn|SP, #imm]!  ···················································  (-256 <= imm < 256)
	2, MatX, MatRefPre, 0x49, 0x98,
	// str Wd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 16384, imm >> 2)
	2, MatW, MatRefOffset, 0x49, 0xa0,
	// str Xd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 32768, imm >> 3)
	2, MatX, MatRefOffset, 0x49, 0xab,
	// str Bd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ·······························  (imm == 0)
	2, MatB, MatRefIndex, 0x49, 0xb6,
	// str Hd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 1])
	2, MatH, MatRefIndex, 0x49, 0xc2,
	// str Sd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 2])
	2, MatS, MatRefIndex, 0x49, 0xce,
	// str Dd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 3])
	2, MatD, MatRefIndex, 0x49, 0xda,
	// str Qd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 4])
	2, MatQ, MatRefIndex, 0x49, 0xe6,
	// str Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 2])
	2, MatW, MatRefIndex, 0x49, 0xf2,
	// str Xd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ··························  (imm in [0, 3])
	2, MatX, MatRefIndex, 0x49, 0xfe,

	4,
	// strb Wd, [Xn|SP], #imm  ···················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x4a, 0xa,
	// strb Wd, [Xn|SP, #imm]!  ··················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x4a, 0x12,
	// strb Wd, [Xn|SP {, #imm }]  ·················································  (0 <= imm < 4096)
	2, MatW, MatRefOffset, 0x4a, 0x1a,
	// strb Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ······························  (imm == 0)
	2, MatW, MatRefIndex, 0x4a, 0x24,

	4,
	// strh Wd, [Xn|SP], #imm  ···················································  (-256 <= imm < 256)
	3, MatW, MatRefBase, MatImm, 0x4a, 0x30,
	// strh Wd, [Xn|SP, #imm]!  ··················································  (-256 <= imm < 256)
	2, MatW, MatRefPre, 0x4a, 0x38,
	// strh Wd, [Xn|SP {, #imm }]  ·······································  (0 <= imm < 8192, imm >> 1)
	2, MatW, MatRefOffset, 0x4a, 0x40,
	// strh Wd, [Xn|SP, Wm|Xm {, LSL|UXTW|SXTW|SXTX #imm }]  ·························  (imm in [0, 1])
	2, MatW, MatRefIndex, 0x4a, 0x4b,

	2,
	// stset Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x57,
	// stset Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4a, 0x5e,

	1,
	// stsetb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x65,

	1,
	// stseth Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x6c,

	2,
	// stsetl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x73,
	// stsetl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4a, 0x7a,

	1,
	// stsetlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x81,

	1,
	// stsetlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x88,

	2,
	// stsmax Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x8f,
	// stsmax Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4a, 0x96,

	1,
	// stsmaxb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0x9d,

	1,
	// stsmaxh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xa4,

	2,
	// stsmaxl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xab,
	// stsmaxl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4a, 0xb2,

	1,
	// stsmaxlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xb9,

	1,
	// stsmaxlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xc0,

	2,
	// stsmin Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xc7,
	// stsmin Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4a, 0xce,

	1,
	// stsminb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xd5,

	1,
	// stsminh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xdc,

	2,
	// stsminl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xe3,
	// stsminl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4a, 0xea,

	1,
	// stsminlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xf1,

	1,
	// stsminlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4a, 0xf8,

	2,
	// sttr Wd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x4a, 0xff,
	// sttr Xd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x4b, 0x7,

	1,
	// sttrb Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x4b, 0xf,

	1,
	// sttrh Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x4b, 0x17,

	2,
	// stumax Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x1f,
	// stumax Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4b, 0x26,

	1,
	// stumaxb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x2d,

	1,
	// stumaxh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x34,

	2,
	// stumaxl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x3b,
	// stumaxl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4b, 0x42,

	1,
	// stumaxlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x49,

	1,
	// stumaxlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x50,

	2,
	// stumin Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x57,
	// stumin Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4b, 0x5e,

	1,
	// stuminb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x65,

	1,
	// stuminh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x6c,

	2,
	// stuminl Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x73,
	// stuminl Xd, [Xn|SP]
	2, MatX, MatRefBase, 0x4b, 0x7a,

	1,
	// stuminlb Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x81,

	1,
	// stuminlh Wd, [Xn|SP]
	2, MatW, MatRefBase, 0x4b, 0x88,

	7,
	// stur Bd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatB, MatRefOffset, 0x4b, 0x8f,
	// stur Hd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatH, MatRefOffset, 0x4b, 0x97,
	// stur Sd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatS, MatRefOffset, 0x4b, 0x9f,
	// stur Dd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatD, MatRefOffset, 0x4b, 0xa7,
	// stur Qd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatQ, MatRefOffset, 0x4b, 0xaf,
	// stur Wd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x4b, 0xb7,
	// stur Xd, [Xn|SP {, #imm }]  ···············································  (-256 <= imm < 256)
	2, MatX, MatRefOffset, 0x4b, 0xbf,

	1,
	// sturb Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x4b, 0xc7,

	1,
	// sturh Wd, [Xn|SP {, #imm }]  ··············································  (-256 <= imm < 256)
	2, MatW, MatRefOffset, 0x4b, 0xcf,

	2,
	// stxp Wd, Wn, Wm, [Xa|SP]
	4, MatW, MatW, MatW, MatRefBase, 0x4b, 0xd7,
	// stxp Wd, Xn, Xm, [Xa|SP]
	4, MatW, MatX, MatX, MatRefBase, 0x4b, 0xe0,

	2,
	// stxr Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4b, 0xe9,
	// stxr Wd, Xn, [Xm|SP]
	3, MatW, MatX, MatRefBase, 0x4b, 0xf1,

	1,
	// stxrb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4b, 0xf9,

	1,
	// stxrh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4c, 0x1,

	12,
	// sub Wd, Wn, Wm {, LSL|LSR|ASR #imm }  ·········································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymShifts, 0x4c, 0x9,
	// sub Xd, Xn, Xm {, LSL|LSR|ASR #imm }  ·········································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymShifts, 0x4c, 0x15,
	// sub Wd|WSP, Wn|WSP, Wm {, LSL|UXT[BHWX]|SXT[BHWX] #imm }  ·····················  (0 <= imm <= 4)
	5, MatWSP, MatWSP, MatW, MatEnd, MatMod, SymExtends, 0x4c, 0x21,
	// sub Xd|SP, Xn|SP, Wm {, UXT[BHW]|SXT[BHW] #imm }  ·····························  (0 <= imm <= 4)
	5, MatXSP, MatXSP, MatW, MatEnd, MatMod, SymExtendsW, 0x4c, 0x2e,
	// sub Xd|SP, Xn|SP, Xm {, LSL|UXTX|SXTX #imm }  ·································  (0 <= imm <= 4)
	5, MatXSP, MatXSP, MatX, MatEnd, MatMod, SymExtendsX, 0x4c, 0x3b,
	// sub Wd|WSP, Wn|WSP, #imm1 {, LSL #imm2 }  ·················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatWSP, MatWSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x4c, 0x48,
	// sub Xd|SP, Xn|SP, #imm1 {, LSL #imm2 }  ···················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatXSP, MatXSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x4c, 0x55,
	// sub Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x4c, 0x62,
	// sub Vd.16B, Vn.16B, Vm.16B
	// sub Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x4c, 0x6a,
	// sub Vd.8H, Vn.8H, Vm.8H
	// sub Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x4c, 0x73,
	// sub Vd.4S, Vn.4S, Vm.4S
	// sub Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x4c, 0x7c,
	// sub Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x4c, 0x85,

	3,
	// subhn Vd.8B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x4c, 0x8e,
	// subhn Vd.4H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x4c, 0x96,
	// subhn Vd.2S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x4c, 0x9e,

	3,
	// subhn2 Vd.16B, Vn.8H, Vm.8H
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x4c, 0xa6,
	// subhn2 Vd.8H, Vn.4S, Vm.4S
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x4c, 0xae,
	// subhn2 Vd.4S, Vn.2D, Vm.2D
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x4c, 0xb6,

	7,
	// subs Wd, Wn, Wm {, LSL|LSR|ASR #imm }  ········································  (0 <= imm < 32)
	5, MatW, MatW, MatW, MatEnd, MatMod, SymShifts, 0x4c, 0xbe,
	// subs Xd, Xn, Xm {, LSL|LSR|ASR #imm }  ········································  (0 <= imm < 64)
	5, MatX, MatX, MatX, MatEnd, MatMod, SymShifts, 0x4c, 0xca,
	// subs Wd, Wn|WSP, Wm {, LSL|UXT[BHWX]|SXT[BHWX] #imm }  ························  (0 <= imm <= 4)
	5, MatW, MatWSP, MatW, MatEnd, MatMod, SymExtends, 0x4c, 0xd6,
	// subs Xd, Xn|SP, Wm {, UXT[BHW]|SXT[BHW] #imm }  ·······························  (0 <= imm <= 4)
	5, MatX, MatXSP, MatW, MatEnd, MatMod, SymExtendsW, 0x4c, 0xe3,
	// subs Xd, Xn|SP, Xm {, LSL|UXTX|SXTX #imm }  ···································  (0 <= imm <= 4)
	5, MatX, MatXSP, MatX, MatEnd, MatMod, SymExtendsX, 0x4c, 0xf0,
	// subs Wd, Wn|WSP, #imm1 {, LSL #imm2 }  ····················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatW, MatWSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x4c, 0xfd,
	// subs Xd, Xn|SP, #imm1 {, LSL #imm2 }  ·····················  (0 <= imm1 < 4096, imm2 in [0, 12])
	5, MatX, MatXSP, MatImm, MatEnd, MatLitMod, SymLSL, 0x4d, 0xa,

	8,
	// suqadd Bd, Bn
	2, MatB, MatB, 0x4d, 0x17,
	// suqadd Hd, Hn
	2, MatH, MatH, 0x4d, 0x1e,
	// suqadd Sd, Sn
	2, MatS, MatS, 0x4d, 0x25,
	// suqadd Dd, Dn
	2, MatD, MatD, 0x4d, 0x2c,
	// suqadd Vd.16B, Vn.16B
	// suqadd Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x4d, 0x33,
	// suqadd Vd.8H, Vn.8H
	// suqadd Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x4d, 0x3b,
	// suqadd Vd.4S, Vn.4S
	// suqadd Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x4d, 0x43,
	// suqadd Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x4d, 0x4b,

	1,
	// svc #imm  ··································································  (0 <= imm < 65536)
	1, MatImm, 0x4d, 0x53,

	2,
	// swp Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0x5b,
	// swp Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4d, 0x63,

	2,
	// swpa Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0x6b,
	// swpa Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4d, 0x73,

	1,
	// swpab Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0x7b,

	1,
	// swpah Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0x83,

	2,
	// swpal Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0x8b,
	// swpal Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4d, 0x93,

	1,
	// swpalb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0x9b,

	1,
	// swpalh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0xa3,

	1,
	// swpb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0xab,

	1,
	// swph Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0xb3,

	2,
	// swpl Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0xbb,
	// swpl Xd, Xn, [Xm|SP]
	3, MatX, MatX, MatRefBase, 0x4d, 0xc3,

	1,
	// swplb Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0xcb,

	1,
	// swplh Wd, Wn, [Xm|SP]
	3, MatW, MatW, MatRefBase, 0x4d, 0xd3,

	2,
	// sxtb Wd, Wn
	2, MatW, MatW, 0x4d, 0xdb,
	// sxtb Xd, Wn
	2, MatX, MatW, 0x4d, 0xe2,

	2,
	// sxth Wd, Wn
	2, MatW, MatW, 0x4d, 0xe9,
	// sxth Xd, Wn
	2, MatX, MatW, 0x4d, 0xf0,

	3,
	// sxtl Vd.8H, Vn.8B
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, 0x4d, 0xf7,
	// sxtl Vd.4S, Vn.4H
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0x4d, 0xfe,
	// sxtl Vd.2D, Vn.2S
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0x4e, 0x5,

	3,
	// sxtl2 Vd.8H, Vn.16B
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, 0x4e, 0xc,
	// sxtl2 Vd.4S, Vn.8H
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0x4e, 0x13,
	// sxtl2 Vd.2D, Vn.4S
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0x4e, 0x1a,

	1,
	// sxtw Xd, Wn
	2, MatX, MatW, 0x4e, 0x21,

	1,
	// sys #imm1, <symbol>, <symbol>, #imm2 {, Xn }  ··················  (0 <= imm1 < 8, 0 <= imm2 < 8)
	6, MatImm, MatSymbol, MatSymbol, MatImm, MatEnd, MatX, 0x4e, 0x28,

	1,
	// sysl Xd, #imm1, <symbol>, <symbol>, #imm2  ·····················  (0 <= imm1 < 8, 0 <= imm2 < 8)
	5, MatX, MatImm, MatSymbol, MatSymbol, MatImm, 0x4e, 0x3a,

	4,
	// tbl Vd.16B, {Vn.16B * 2}, Vm.16B
	// tbl Vd.8B, {Vn.16B * 2}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 2, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0x4c,
	// tbl Vd.16B, {Vn.16B * 3}, Vm.16B
	// tbl Vd.8B, {Vn.16B * 3}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 3, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0x55,
	// tbl Vd.16B, {Vn.16B * 4}, Vm.16B
	// tbl Vd.8B, {Vn.16B * 4}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 4, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0x5e,
	// tbl Vd.16B, {Vn.16B * 1}, Vm.16B
	// tbl Vd.8B, {Vn.16B * 1}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 1, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0x67,

	2,
	// tbnz Wd, #imm, <offset>  ···················  (0 <= imm < 32, offset >> 2 is 14-bit (+/- 32 KB))
	3, MatW, MatImm, MatOffset, 0x4e, 0x70,
	// tbnz Xd, #imm, <offset>  ···················  (0 <= imm < 64, offset >> 2 is 14-bit (+/- 32 KB))
	3, MatX, MatImm, MatOffset, 0x4e, 0x7b,

	4,
	// tbx Vd.16B, {Vn.16B * 2}, Vm.16B
	// tbx Vd.8B, {Vn.16B * 2}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 2, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0x8e,
	// tbx Vd.16B, {Vn.16B * 3}, Vm.16B
	// tbx Vd.8B, {Vn.16B * 3}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 3, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0x97,
	// tbx Vd.16B, {Vn.16B * 4}, Vm.16B
	// tbx Vd.8B, {Vn.16B * 4}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 4, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0xa0,
	// tbx Vd.16B, {Vn.16B * 1}, Vm.16B
	// tbx Vd.8B, {Vn.16B * 1}, Vm.8B
	3, MatV, byte(BYTE), MatRegListStatic, 1, byte(BYTE), 16, MatV, byte(BYTE), 0x4e, 0xa9,

	2,
	// tbz Wd, #imm, <offset>  ····················  (0 <= imm < 32, offset >> 2 is 14-bit (+/- 32 KB))
	3, MatW, MatImm, MatOffset, 0x4e, 0xb2,
	// tbz Xd, #imm, <offset>  ····················  (0 <= imm < 64, offset >> 2 is 14-bit (+/- 32 KB))
	3, MatX, MatImm, MatOffset, 0x4e, 0xbd,

	1,
	// tlbi <symbol> {, Xn }
	3, MatSymbol, MatEnd, MatX, 0x4e, 0xd0,

	4,
	// trn1 Vd.16B, Vn.16B, Vm.16B
	// trn1 Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x4e, 0xd9,
	// trn1 Vd.8H, Vn.8H, Vm.8H
	// trn1 Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x4e, 0xe2,
	// trn1 Vd.4S, Vn.4S, Vm.4S
	// trn1 Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x4e, 0xeb,
	// trn1 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x4e, 0xf4,

	4,
	// trn2 Vd.16B, Vn.16B, Vm.16B
	// trn2 Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x4e, 0xfd,
	// trn2 Vd.8H, Vn.8H, Vm.8H
	// trn2 Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x4f, 0x6,
	// trn2 Vd.4S, Vn.4S, Vm.4S
	// trn2 Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x4f, 0xf,
	// trn2 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x4f, 0x18,

	1,
	// tsb CSYNC
	1, MatLitSymbol, byte(CSYNC), 0x4f, 0x21,

	4,
	// tst Wd, #imm  ·························································  (imm is 32-bit logical)
	2, MatW, MatImm, 0x4f, 0x26,
	// tst Xd, #imm  ·························································  (imm is 64-bit logical)
	2, MatX, MatImm, 0x4f, 0x2f,
	// tst Wd, Wn {, LSL|LSR|ASR|ROR #imm }  ·········································  (0 <= imm < 32)
	4, MatW, MatW, MatEnd, MatMod, SymRotates, 0x4f, 0x38,
	// tst Xd, Xn {, LSL|LSR|ASR|ROR #imm }  ·········································  (0 <= imm < 64)
	4, MatX, MatX, MatEnd, MatMod, SymRotates, 0x4f, 0x43,

	3,
	// uaba Vd.16B, Vn.16B, Vm.16B
	// uaba Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x4f, 0x4e,
	// uaba Vd.8H, Vn.8H, Vm.8H
	// uaba Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x4f, 0x57,
	// uaba Vd.4S, Vn.4S, Vm.4S
	// uaba Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x4f, 0x60,

	3,
	// uabal Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x4f, 0x69,
	// uabal Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x4f, 0x71,
	// uabal Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x4f, 0x79,

	3,
	// uabal2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x4f, 0x81,
	// uabal2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x4f, 0x89,
	// uabal2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x4f, 0x91,

	3,
	// uabd Vd.16B, Vn.16B, Vm.16B
	// uabd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x4f, 0x99,
	// uabd Vd.8H, Vn.8H, Vm.8H
	// uabd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x4f, 0xa2,
	// uabd Vd.4S, Vn.4S, Vm.4S
	// uabd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x4f, 0xab,

	3,
	// uabdl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x4f, 0xb4,
	// uabdl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x4f, 0xbc,
	// uabdl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x4f, 0xc4,

	3,
	// uabdl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x4f, 0xcc,
	// uabdl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x4f, 0xd4,
	// uabdl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x4f, 0xdc,

	3,
	// uadalp Vd.8H, Vn.16B
	// uadalp Vd.4H, Vn.8B
	2, MatV, byte(WORD), MatV, byte(BYTE), 0x4f, 0xe4,
	// uadalp Vd.4S, Vn.8H
	// uadalp Vd.2S, Vn.4H
	2, MatV, byte(DWORD), MatV, byte(WORD), 0x4f, 0xec,
	// uadalp Vd.2D, Vn.4S
	// uadalp Vd.1D, Vn.2S
	2, MatV, byte(QWORD), MatV, byte(DWORD), 0x4f, 0xf4,

	3,
	// uaddl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x4f, 0xfc,
	// uaddl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x50, 0x4,
	// uaddl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x50, 0xc,

	3,
	// uaddl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x50, 0x14,
	// uaddl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x50, 0x1c,
	// uaddl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x50, 0x24,

	3,
	// uaddlp Vd.8H, Vn.16B
	// uaddlp Vd.4H, Vn.8B
	2, MatV, byte(WORD), MatV, byte(BYTE), 0x50, 0x2c,
	// uaddlp Vd.4S, Vn.8H
	// uaddlp Vd.2S, Vn.4H
	2, MatV, byte(DWORD), MatV, byte(WORD), 0x50, 0x34,
	// uaddlp Vd.2D, Vn.4S
	// uaddlp Vd.1D, Vn.2S
	2, MatV, byte(QWORD), MatV, byte(DWORD), 0x50, 0x3c,

	3,
	// uaddlv Hd, Vn.16B
	// uaddlv Hd, Vn.8B
	2, MatH, MatV, byte(BYTE), 0x50, 0x44,
	// uaddlv Sd, Vn.8H
	// uaddlv Sd, Vn.4H
	2, MatS, MatV, byte(WORD), 0x50, 0x4c,
	// uaddlv Dd, Vn.4S
	2, MatD, MatVStatic, byte(DWORD), 4, 0x50, 0x54,

	3,
	// uaddw Vd.8H, Vn.8H, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, 0x50, 0x5c,
	// uaddw Vd.4S, Vn.4S, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0x50, 0x64,
	// uaddw Vd.2D, Vn.2D, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0x50, 0x6c,

	3,
	// uaddw2 Vd.8H, Vn.8H, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, 0x50, 0x74,
	// uaddw2 Vd.4S, Vn.4S, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0x50, 0x7c,
	// uaddw2 Vd.2D, Vn.2D, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0x50, 0x84,

	2,
	// ubfiz Wd, Wn, #imm1, #imm2  ···············  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	4, MatW, MatW, MatImm, MatImm, 0x50, 0x8c,
	// ubfiz Xd, Xn, #imm1, #imm2  ···············  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x50, 0x9c,

	2,
	// ubfm Wd, Wn, #imm1, #imm2  ···································  (0 <= imm1 < 32, 0 <= imm2 < 32)
	4, MatW, MatW, MatImm, MatImm, 0x50, 0xac,
	// ubfm Xd, Xn, #imm1, #imm2  ·················  (0 <= imm1 < 64, 0 < imm2 < 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x50, 0xb9,

	2,
	// ubfx Wd, Wn, #imm1, #imm2  ················  (0 <= imm1 < 32, 0 < imm2 <= 32, imm1 + imm2 <= 32)
	4, MatW, MatW, MatImm, MatImm, 0x50, 0xc8,
	// ubfx Xd, Xn, #imm1, #imm2  ················  (0 <= imm1 < 64, 0 < imm2 <= 64, imm1 + imm2 <= 64)
	4, MatX, MatX, MatImm, MatImm, 0x50, 0xd7,

	24,
	// ucvtf Hd, Hn, #imm  ···························································  (0 < imm <= 16)
	3, MatH, MatH, MatImm, 0x50, 0xe6,
	// ucvtf Sd, Sn, #imm  ···························································  (0 < imm <= 32)
	3, MatS, MatS, MatImm, 0x50, 0xf3,
	// ucvtf Dd, Dn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x51, 0x0,
	// ucvtf Vd.8H, Vn.8H, #imm  ·····················································  (0 < imm <= 16)
	// ucvtf Vd.4H, Vn.4H, #imm  ·····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x51, 0xd,
	// ucvtf Vd.4S, Vn.4S, #imm  ·····················································  (0 < imm <= 32)
	// ucvtf Vd.2S, Vn.2S, #imm  ·····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x51, 0x19,
	// ucvtf Vd.2D, Vn.2D, #imm  ·····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x51, 0x25,
	// ucvtf Hd, Hn
	2, MatH, MatH, 0x51, 0x31,
	// ucvtf Sd, Sn
	2, MatS, MatS, 0x51, 0x38,
	// ucvtf Dd, Dn
	2, MatD, MatD, 0x51, 0x3f,
	// ucvtf Vd.8H, Vn.8H
	// ucvtf Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x51, 0x46,
	// ucvtf Vd.4S, Vn.4S
	// ucvtf Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x51, 0x4e,
	// ucvtf Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x51, 0x56,
	// ucvtf Hd, Wn, #imm  ···························································  (0 < imm <= 32)
	3, MatH, MatW, MatImm, 0x51, 0x5e,
	// ucvtf Sd, Wn, #imm  ···························································  (0 < imm <= 32)
	3, MatS, MatW, MatImm, 0x51, 0x6b,
	// ucvtf Dd, Wn, #imm  ···························································  (0 < imm <= 32)
	3, MatD, MatW, MatImm, 0x51, 0x78,
	// ucvtf Hd, Xn, #imm  ···························································  (0 < imm <= 64)
	3, MatH, MatX, MatImm, 0x51, 0x85,
	// ucvtf Sd, Xn, #imm  ···························································  (0 < imm <= 64)
	3, MatS, MatX, MatImm, 0x51, 0x90,
	// ucvtf Dd, Xn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatX, MatImm, 0x51, 0x9b,
	// ucvtf Hd, Wn
	2, MatH, MatW, 0x51, 0xa6,
	// ucvtf Sd, Wn
	2, MatS, MatW, 0x51, 0xad,
	// ucvtf Dd, Wn
	2, MatD, MatW, 0x51, 0xb4,
	// ucvtf Hd, Xn
	2, MatH, MatX, 0x51, 0xbb,
	// ucvtf Sd, Xn
	2, MatS, MatX, 0x51, 0xc2,
	// ucvtf Dd, Xn
	2, MatD, MatX, 0x51, 0xc9,

	1,
	// udf #imm  ··································································  (0 <= imm < 65536)
	1, MatImm, 0x51, 0xd0,

	2,
	// udiv Wd, Wn, Wm
	3, MatW, MatW, MatW, 0x51, 0xd8,
	// udiv Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x51, 0xe0,

	4,
	// udot Vd.2S, Vn.8B, Vm.4B[i]
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(BYTE), 8, MatVStaticElement, byte(BYTE), 4, 0x51, 0xe8,
	// udot Vd.4S, Vn.16B, Vm.4B[i]
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(BYTE), 16, MatVStaticElement, byte(BYTE), 4, 0x51, 0xf2,
	// udot Vd.2S, Vn.8B, Vm.8B
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x51, 0xfc,
	// udot Vd.4S, Vn.16B, Vm.16B
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x52, 0x4,

	3,
	// uhadd Vd.16B, Vn.16B, Vm.16B
	// uhadd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x52, 0xc,
	// uhadd Vd.8H, Vn.8H, Vm.8H
	// uhadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x52, 0x15,
	// uhadd Vd.4S, Vn.4S, Vm.4S
	// uhadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x52, 0x1e,

	3,
	// uhsub Vd.16B, Vn.16B, Vm.16B
	// uhsub Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x52, 0x27,
	// uhsub Vd.8H, Vn.8H, Vm.8H
	// uhsub Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x52, 0x30,
	// uhsub Vd.4S, Vn.4S, Vm.4S
	// uhsub Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x52, 0x39,

	1,
	// umaddl Xd, Wn, Wm, Xa
	4, MatX, MatW, MatW, MatX, 0x52, 0x42,

	3,
	// umax Vd.16B, Vn.16B, Vm.16B
	// umax Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x52, 0x4b,
	// umax Vd.8H, Vn.8H, Vm.8H
	// umax Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x52, 0x54,
	// umax Vd.4S, Vn.4S, Vm.4S
	// umax Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x52, 0x5d,

	3,
	// umaxp Vd.16B, Vn.16B, Vm.16B
	// umaxp Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x52, 0x66,
	// umaxp Vd.8H, Vn.8H, Vm.8H
	// umaxp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x52, 0x6f,
	// umaxp Vd.4S, Vn.4S, Vm.4S
	// umaxp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x52, 0x78,

	3,
	// umaxv Bd, Vn.16B
	// umaxv Bd, Vn.8B
	2, MatB, MatV, byte(BYTE), 0x52, 0x81,
	// umaxv Hd, Vn.8H
	// umaxv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x52, 0x89,
	// umaxv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x52, 0x91,

	3,
	// umin Vd.16B, Vn.16B, Vm.16B
	// umin Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x52, 0x99,
	// umin Vd.8H, Vn.8H, Vm.8H
	// umin Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x52, 0xa2,
	// umin Vd.4S, Vn.4S, Vm.4S
	// umin Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x52, 0xab,

	3,
	// uminp Vd.16B, Vn.16B, Vm.16B
	// uminp Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x52, 0xb4,
	// uminp Vd.8H, Vn.8H, Vm.8H
	// uminp Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x52, 0xbd,
	// uminp Vd.4S, Vn.4S, Vm.4S
	// uminp Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x52, 0xc6,

	3,
	// uminv Bd, Vn.16B
	// uminv Bd, Vn.8B
	2, MatB, MatV, byte(BYTE), 0x52, 0xcf,
	// uminv Hd, Vn.8H
	// uminv Hd, Vn.4H
	2, MatH, MatV, byte(WORD), 0x52, 0xd7,
	// uminv Sd, Vn.4S
	2, MatS, MatVStatic, byte(DWORD), 4, 0x52, 0xdf,

	5,
	// umlal Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x52, 0xe7,
	// umlal Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x52, 0xf1,
	// umlal Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x52, 0xfb,
	// umlal Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x53, 0x3,
	// umlal Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x53, 0xb,

	5,
	// umlal2 Vd.4S, Vn.8H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x53, 0x13,
	// umlal2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x53, 0x1d,
	// umlal2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x53, 0x27,
	// umlal2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x53, 0x2f,
	// umlal2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x53, 0x37,

	5,
	// umlsl Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x53, 0x3f,
	// umlsl Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x53, 0x49,
	// umlsl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x53, 0x53,
	// umlsl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x53, 0x5b,
	// umlsl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x53, 0x63,

	5,
	// umlsl2 Vd.4S, Vn.8H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x53, 0x6b,
	// umlsl2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x53, 0x75,
	// umlsl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x53, 0x7f,
	// umlsl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x53, 0x87,
	// umlsl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x53, 0x8f,

	1,
	// umnegl Xd, Wn, Wm
	3, MatX, MatW, MatW, 0x53, 0x97,

	4,
	// umov Wd, Vn.B[i]
	2, MatW, MatVElement, byte(BYTE), 0x53, 0x9f,
	// umov Wd, Vn.H[i]
	2, MatW, MatVElement, byte(WORD), 0x53, 0xa9,
	// umov Wd, Vn.S[i]
	2, MatW, MatVElement, byte(DWORD), 0x53, 0xb3,
	// umov Xd, Vn.D[i]
	2, MatX, MatVElement, byte(QWORD), 0x53, 0xbd,

	1,
	// umsubl Xd, Wn, Wm, Xa
	4, MatX, MatW, MatW, MatX, 0x53, 0xc7,

	1,
	// umulh Xd, Xn, Xm
	3, MatX, MatX, MatX, 0x53, 0xd0,

	6,
	// umull Vd.4S, Vn.4H, Vm.H[i]  ·························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVElement, byte(WORD), 0x53, 0xd8,
	// umull Vd.2D, Vn.2S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVElement, byte(DWORD), 0x53, 0xe2,
	// umull Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x53, 0xec,
	// umull Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x53, 0xf4,
	// umull Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x53, 0xfc,
	// umull Xd, Wn, Wm
	3, MatX, MatW, MatW, 0x54, 0x4,

	5,
	// umull2 Vd.4S, Vn.8H, Vm.H[i]  ························································  (m < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVElement, byte(WORD), 0x54, 0xc,
	// umull2 Vd.2D, Vn.4S, Vm.S[i]
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVElement, byte(DWORD), 0x54, 0x16,
	// umull2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x54, 0x20,
	// umull2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x54, 0x28,
	// umull2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x54, 0x30,

	8,
	// uqadd Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x54, 0x38,
	// uqadd Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x54, 0x40,
	// uqadd Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x54, 0x48,
	// uqadd Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x54, 0x50,
	// uqadd Vd.16B, Vn.16B, Vm.16B
	// uqadd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x54, 0x58,
	// uqadd Vd.8H, Vn.8H, Vm.8H
	// uqadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x54, 0x61,
	// uqadd Vd.4S, Vn.4S, Vm.4S
	// uqadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x54, 0x6a,
	// uqadd Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x54, 0x73,

	8,
	// uqrshl Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x54, 0x7c,
	// uqrshl Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x54, 0x84,
	// uqrshl Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x54, 0x8c,
	// uqrshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x54, 0x94,
	// uqrshl Vd.16B, Vn.16B, Vm.16B
	// uqrshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x54, 0x9c,
	// uqrshl Vd.8H, Vn.8H, Vm.8H
	// uqrshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x54, 0xa5,
	// uqrshl Vd.4S, Vn.4S, Vm.4S
	// uqrshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x54, 0xae,
	// uqrshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x54, 0xb7,

	6,
	// uqrshrn Bd, Hn, #imm  ··························································  (0 < imm <= 8)
	3, MatB, MatH, MatImm, 0x54, 0xc0,
	// uqrshrn Hd, Sn, #imm  ·························································  (0 < imm <= 16)
	3, MatH, MatS, MatImm, 0x54, 0xcd,
	// uqrshrn Sd, Dn, #imm  ·························································  (0 < imm <= 32)
	3, MatS, MatD, MatImm, 0x54, 0xda,
	// uqrshrn Vd.8B, Vn.8H, #imm  ····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x54, 0xe7,
	// uqrshrn Vd.4H, Vn.4S, #imm  ···················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x54, 0xf2,
	// uqrshrn Vd.2S, Vn.2D, #imm  ···················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x54, 0xfd,

	3,
	// uqrshrn2 Vd.16B, Vn.8H, #imm  ··················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x55, 0x8,
	// uqrshrn2 Vd.8H, Vn.4S, #imm  ··················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x55, 0x13,
	// uqrshrn2 Vd.4S, Vn.2D, #imm  ··················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x55, 0x1e,

	16,
	// uqshl Bd, Bn, #imm  ····························································  (0 <= imm < 8)
	3, MatB, MatB, MatImm, 0x55, 0x29,
	// uqshl Hd, Hn, #imm  ···························································  (0 <= imm < 16)
	3, MatH, MatH, MatImm, 0x55, 0x33,
	// uqshl Sd, Sn, #imm  ···························································  (0 <= imm < 32)
	3, MatS, MatS, MatImm, 0x55, 0x3d,
	// uqshl Dd, Dn, #imm  ···························································  (0 <= imm < 64)
	3, MatD, MatD, MatImm, 0x55, 0x47,
	// uqshl Vd.16B, Vn.16B, #imm  ····················································  (0 <= imm < 8)
	// uqshl Vd.8B, Vn.8B, #imm  ······················································  (0 <= imm < 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x55, 0x51,
	// uqshl Vd.8H, Vn.8H, #imm  ·····················································  (0 <= imm < 16)
	// uqshl Vd.4H, Vn.4H, #imm  ·····················································  (0 <= imm < 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x55, 0x5c,
	// uqshl Vd.4S, Vn.4S, #imm  ·····················································  (0 <= imm < 32)
	// uqshl Vd.2S, Vn.2S, #imm  ·····················································  (0 <= imm < 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x55, 0x67,
	// uqshl Vd.2D, Vn.2D, #imm  ·····················································  (0 <= imm < 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x55, 0x72,
	// uqshl Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x55, 0x7d,
	// uqshl Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x55, 0x85,
	// uqshl Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x55, 0x8d,
	// uqshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x55, 0x95,
	// uqshl Vd.16B, Vn.16B, Vm.16B
	// uqshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x55, 0x9d,
	// uqshl Vd.8H, Vn.8H, Vm.8H
	// uqshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x55, 0xa6,
	// uqshl Vd.4S, Vn.4S, Vm.4S
	// uqshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x55, 0xaf,
	// uqshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x55, 0xb8,

	6,
	// uqshrn Bd, Hn, #imm  ···························································  (0 < imm <= 8)
	3, MatB, MatH, MatImm, 0x55, 0xc1,
	// uqshrn Hd, Sn, #imm  ··························································  (0 < imm <= 16)
	3, MatH, MatS, MatImm, 0x55, 0xce,
	// uqshrn Sd, Dn, #imm  ··························································  (0 < imm <= 32)
	3, MatS, MatD, MatImm, 0x55, 0xdb,
	// uqshrn Vd.8B, Vn.8H, #imm  ·····················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, MatImm, 0x55, 0xe8,
	// uqshrn Vd.4H, Vn.4S, #imm  ····················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, MatImm, 0x55, 0xf3,
	// uqshrn Vd.2S, Vn.2D, #imm  ····················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x55, 0xfe,

	3,
	// uqshrn2 Vd.16B, Vn.8H, #imm  ···················································  (0 < imm <= 8)
	3, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, MatImm, 0x56, 0x9,
	// uqshrn2 Vd.8H, Vn.4S, #imm  ···················································  (0 < imm <= 16)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, MatImm, 0x56, 0x14,
	// uqshrn2 Vd.4S, Vn.2D, #imm  ···················································  (0 < imm <= 32)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, MatImm, 0x56, 0x1f,

	8,
	// uqsub Bd, Bn, Bm
	3, MatB, MatB, MatB, 0x56, 0x2a,
	// uqsub Hd, Hn, Hm
	3, MatH, MatH, MatH, 0x56, 0x32,
	// uqsub Sd, Sn, Sm
	3, MatS, MatS, MatS, 0x56, 0x3a,
	// uqsub Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x56, 0x42,
	// uqsub Vd.16B, Vn.16B, Vm.16B
	// uqsub Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x56, 0x4a,
	// uqsub Vd.8H, Vn.8H, Vm.8H
	// uqsub Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x56, 0x53,
	// uqsub Vd.4S, Vn.4S, Vm.4S
	// uqsub Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x56, 0x5c,
	// uqsub Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x56, 0x65,

	6,
	// uqxtn Bd, Hn
	2, MatB, MatH, 0x56, 0x6e,
	// uqxtn Hd, Sn
	2, MatH, MatS, 0x56, 0x75,
	// uqxtn Sd, Dn
	2, MatS, MatD, 0x56, 0x7c,
	// uqxtn Vd.8B, Vn.8H
	2, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, 0x56, 0x83,
	// uqxtn Vd.4H, Vn.4S
	2, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, 0x56, 0x8a,
	// uqxtn Vd.2S, Vn.2D
	2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, 0x56, 0x91,

	3,
	// uqxtn2 Vd.16B, Vn.8H
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, 0x56, 0x98,
	// uqxtn2 Vd.8H, Vn.4S
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, 0x56, 0x9f,
	// uqxtn2 Vd.4S, Vn.2D
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, 0x56, 0xa6,

	1,
	// urecpe Vd.4S, Vn.4S
	// urecpe Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x56, 0xad,

	3,
	// urhadd Vd.16B, Vn.16B, Vm.16B
	// urhadd Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x56, 0xb5,
	// urhadd Vd.8H, Vn.8H, Vm.8H
	// urhadd Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x56, 0xbe,
	// urhadd Vd.4S, Vn.4S, Vm.4S
	// urhadd Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x56, 0xc7,

	5,
	// urshl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x56, 0xd0,
	// urshl Vd.16B, Vn.16B, Vm.16B
	// urshl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x56, 0xd8,
	// urshl Vd.8H, Vn.8H, Vm.8H
	// urshl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x56, 0xe1,
	// urshl Vd.4S, Vn.4S, Vm.4S
	// urshl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x56, 0xea,
	// urshl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x56, 0xf3,

	5,
	// urshr Dd, Dn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x56, 0xfc,
	// urshr Vd.16B, Vn.16B, #imm  ····················································  (0 < imm <= 8)
	// urshr Vd.8B, Vn.8B, #imm  ······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x57, 0x9,
	// urshr Vd.8H, Vn.8H, #imm  ·····················································  (0 < imm <= 16)
	// urshr Vd.4H, Vn.4H, #imm  ·····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x57, 0x15,
	// urshr Vd.4S, Vn.4S, #imm  ·····················································  (0 < imm <= 32)
	// urshr Vd.2S, Vn.2S, #imm  ·····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x57, 0x21,
	// urshr Vd.2D, Vn.2D, #imm  ·····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x57, 0x2d,

	1,
	// ursqrte Vd.4S, Vn.4S
	// ursqrte Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x57, 0x39,

	5,
	// ursra Dd, Dn, #imm  ···························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x57, 0x41,
	// ursra Vd.16B, Vn.16B, #imm  ····················································  (0 < imm <= 8)
	// ursra Vd.8B, Vn.8B, #imm  ······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x57, 0x4e,
	// ursra Vd.8H, Vn.8H, #imm  ·····················································  (0 < imm <= 16)
	// ursra Vd.4H, Vn.4H, #imm  ·····················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x57, 0x5a,
	// ursra Vd.4S, Vn.4S, #imm  ·····················································  (0 < imm <= 32)
	// ursra Vd.2S, Vn.2S, #imm  ·····················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x57, 0x66,
	// ursra Vd.2D, Vn.2D, #imm  ·····················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x57, 0x72,

	5,
	// ushl Dd, Dn, Dm
	3, MatD, MatD, MatD, 0x57, 0x7e,
	// ushl Vd.16B, Vn.16B, Vm.16B
	// ushl Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x57, 0x86,
	// ushl Vd.8H, Vn.8H, Vm.8H
	// ushl Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x57, 0x8f,
	// ushl Vd.4S, Vn.4S, Vm.4S
	// ushl Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x57, 0x98,
	// ushl Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x57, 0xa1,

	3,
	// ushll Vd.8H, Vn.8B, #imm  ······················································  (0 <= imm < 8)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatImm, 0x57, 0xaa,
	// ushll Vd.4S, Vn.4H, #imm  ·····················································  (0 <= imm < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatImm, 0x57, 0xb4,
	// ushll Vd.2D, Vn.2S, #imm  ·····················································  (0 <= imm < 32)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatImm, 0x57, 0xbe,

	3,
	// ushll2 Vd.8H, Vn.16B, #imm  ····················································  (0 <= imm < 8)
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatImm, 0x57, 0xc8,
	// ushll2 Vd.4S, Vn.8H, #imm  ····················································  (0 <= imm < 16)
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatImm, 0x57, 0xd2,
	// ushll2 Vd.2D, Vn.4S, #imm  ····················································  (0 <= imm < 32)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatImm, 0x57, 0xdc,

	5,
	// ushr Dd, Dn, #imm  ····························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x57, 0xe6,
	// ushr Vd.16B, Vn.16B, #imm  ·····················································  (0 < imm <= 8)
	// ushr Vd.8B, Vn.8B, #imm  ·······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x57, 0xf3,
	// ushr Vd.8H, Vn.8H, #imm  ······················································  (0 < imm <= 16)
	// ushr Vd.4H, Vn.4H, #imm  ······················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x57, 0xff,
	// ushr Vd.4S, Vn.4S, #imm  ······················································  (0 < imm <= 32)
	// ushr Vd.2S, Vn.2S, #imm  ······················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x58, 0xb,
	// ushr Vd.2D, Vn.2D, #imm  ······················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x58, 0x17,

	8,
	// usqadd Bd, Bn
	2, MatB, MatB, 0x58, 0x23,
	// usqadd Hd, Hn
	2, MatH, MatH, 0x58, 0x2a,
	// usqadd Sd, Sn
	2, MatS, MatS, 0x58, 0x31,
	// usqadd Dd, Dn
	2, MatD, MatD, 0x58, 0x38,
	// usqadd Vd.16B, Vn.16B
	// usqadd Vd.8B, Vn.8B
	2, MatV, byte(BYTE), MatV, byte(BYTE), 0x58, 0x3f,
	// usqadd Vd.8H, Vn.8H
	// usqadd Vd.4H, Vn.4H
	2, MatV, byte(WORD), MatV, byte(WORD), 0x58, 0x47,
	// usqadd Vd.4S, Vn.4S
	// usqadd Vd.2S, Vn.2S
	2, MatV, byte(DWORD), MatV, byte(DWORD), 0x58, 0x4f,
	// usqadd Vd.2D, Vn.2D
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x58, 0x57,

	5,
	// usra Dd, Dn, #imm  ····························································  (0 < imm <= 64)
	3, MatD, MatD, MatImm, 0x58, 0x5f,
	// usra Vd.16B, Vn.16B, #imm  ·····················································  (0 < imm <= 8)
	// usra Vd.8B, Vn.8B, #imm  ·······················································  (0 < imm <= 8)
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatImm, 0x58, 0x6c,
	// usra Vd.8H, Vn.8H, #imm  ······················································  (0 < imm <= 16)
	// usra Vd.4H, Vn.4H, #imm  ······················································  (0 < imm <= 16)
	3, MatV, byte(WORD), MatV, byte(WORD), MatImm, 0x58, 0x78,
	// usra Vd.4S, Vn.4S, #imm  ······················································  (0 < imm <= 32)
	// usra Vd.2S, Vn.2S, #imm  ······················································  (0 < imm <= 32)
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatImm, 0x58, 0x84,
	// usra Vd.2D, Vn.2D, #imm  ······················································  (0 < imm <= 64)
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x58, 0x90,

	3,
	// usubl Vd.8H, Vn.8B, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, MatVStatic, byte(BYTE), 8, 0x58, 0x9c,
	// usubl Vd.4S, Vn.4H, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, MatVStatic, byte(WORD), 4, 0x58, 0xa4,
	// usubl Vd.2D, Vn.2S, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(DWORD), 2, 0x58, 0xac,

	3,
	// usubl2 Vd.8H, Vn.16B, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, MatVStatic, byte(BYTE), 16, 0x58, 0xb4,
	// usubl2 Vd.4S, Vn.8H, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, 0x58, 0xbc,
	// usubl2 Vd.2D, Vn.4S, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, 0x58, 0xc4,

	3,
	// usubw Vd.8H, Vn.8H, Vm.8B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, 0x58, 0xcc,
	// usubw Vd.4S, Vn.4S, Vm.4H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0x58, 0xd4,
	// usubw Vd.2D, Vn.2D, Vm.2S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0x58, 0xdc,

	3,
	// usubw2 Vd.8H, Vn.8H, Vm.16B
	3, MatVStatic, byte(WORD), 8, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, 0x58, 0xe4,
	// usubw2 Vd.4S, Vn.4S, Vm.8H
	3, MatVStatic, byte(DWORD), 4, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0x58, 0xec,
	// usubw2 Vd.2D, Vn.2D, Vm.4S
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0x58, 0xf4,

	1,
	// uxtb Wd, Wn
	2, MatW, MatW, 0x58, 0xfc,

	1,
	// uxth Wd, Wn
	2, MatW, MatW, 0x59, 0x3,

	3,
	// uxtl Vd.8H, Vn.8B
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 8, 0x59, 0xa,
	// uxtl Vd.4S, Vn.4H
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 4, 0x59, 0x11,
	// uxtl Vd.2D, Vn.2S
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 2, 0x59, 0x18,

	3,
	// uxtl2 Vd.8H, Vn.16B
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(BYTE), 16, 0x59, 0x1f,
	// uxtl2 Vd.4S, Vn.8H
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(WORD), 8, 0x59, 0x26,
	// uxtl2 Vd.2D, Vn.4S
	2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(DWORD), 4, 0x59, 0x2d,

	4,
	// uzp1 Vd.16B, Vn.16B, Vm.16B
	// uzp1 Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x59, 0x34,
	// uzp1 Vd.8H, Vn.8H, Vm.8H
	// uzp1 Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x59, 0x3d,
	// uzp1 Vd.4S, Vn.4S, Vm.4S
	// uzp1 Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x59, 0x46,
	// uzp1 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x59, 0x4f,

	4,
	// uzp2 Vd.16B, Vn.16B, Vm.16B
	// uzp2 Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x59, 0x58,
	// uzp2 Vd.8H, Vn.8H, Vm.8H
	// uzp2 Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x59, 0x61,
	// uzp2 Vd.4S, Vn.4S, Vm.4S
	// uzp2 Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x59, 0x6a,
	// uzp2 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x59, 0x73,

	1,
	// wfe
	0, 0x59, 0x7c,

	1,
	// wfi
	0, 0x59, 0x81,

	1,
	// xar Vd.2D, Vn.2D, Vm.2D, #imm  ················································  (0 <= imm < 64)
	4, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatImm, 0x59, 0x86,

	1,
	// xpacd Xd
	1, MatX, 0x59, 0x91,

	1,
	// xpaci Xd
	1, MatX, 0x59, 0x97,

	1,
	// xpaclri
	0, 0x59, 0x9d,

	3,
	// xtn Vd.8B, Vn.8H
	2, MatVStatic, byte(BYTE), 8, MatVStatic, byte(WORD), 8, 0x59, 0xa2,
	// xtn Vd.4H, Vn.4S
	2, MatVStatic, byte(WORD), 4, MatVStatic, byte(DWORD), 4, 0x59, 0xa9,
	// xtn Vd.2S, Vn.2D
	2, MatVStatic, byte(DWORD), 2, MatVStatic, byte(QWORD), 2, 0x59, 0xb0,

	3,
	// xtn2 Vd.16B, Vn.8H
	2, MatVStatic, byte(BYTE), 16, MatVStatic, byte(WORD), 8, 0x59, 0xb7,
	// xtn2 Vd.8H, Vn.4S
	2, MatVStatic, byte(WORD), 8, MatVStatic, byte(DWORD), 4, 0x59, 0xbe,
	// xtn2 Vd.4S, Vn.2D
	2, MatVStatic, byte(DWORD), 4, MatVStatic, byte(QWORD), 2, 0x59, 0xc5,

	1,
	// yield
	0, 0x59, 0xcc,

	4,
	// zip1 Vd.16B, Vn.16B, Vm.16B
	// zip1 Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x59, 0xd1,
	// zip1 Vd.8H, Vn.8H, Vm.8H
	// zip1 Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x59, 0xda,
	// zip1 Vd.4S, Vn.4S, Vm.4S
	// zip1 Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x59, 0xe3,
	// zip1 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x59, 0xec,

	4,
	// zip2 Vd.16B, Vn.16B, Vm.16B
	// zip2 Vd.8B, Vn.8B, Vm.8B
	3, MatV, byte(BYTE), MatV, byte(BYTE), MatV, byte(BYTE), 0x59, 0xf5,
	// zip2 Vd.8H, Vn.8H, Vm.8H
	// zip2 Vd.4H, Vn.4H, Vm.4H
	3, MatV, byte(WORD), MatV, byte(WORD), MatV, byte(WORD), 0x59, 0xfe,
	// zip2 Vd.4S, Vn.4S, Vm.4S
	// zip2 Vd.2S, Vn.2S, Vm.2S
	3, MatV, byte(DWORD), MatV, byte(DWORD), MatV, byte(DWORD), 0x5a, 0x7,
	// zip2 Vd.2D, Vn.2D, Vm.2D
	3, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, MatVStatic, byte(QWORD), 2, 0x5a, 0x10,
}