[llvm] 1a91756 - [AArch64]SME2 MOV Instructions
Caroline Concatto via llvm-commits
llvm-commits at lists.llvm.org
Tue Nov 8 01:54:25 PST 2022
Author: Caroline Concatto
Date: 2022-11-08T09:51:56Z
New Revision: 1a917568e7321b4cc36313895cc98408ffa861ec
URL: https://github.com/llvm/llvm-project/commit/1a917568e7321b4cc36313895cc98408ffa861ec
DIFF: https://github.com/llvm/llvm-project/commit/1a917568e7321b4cc36313895cc98408ffa861ec.diff
LOG: [AArch64]SME2 MOV Instructions
This patch adds the assembly/disassembly for the following instructions:
MOVA (array to vector, four registers): Move four ZA single-vector groups to four vector registers.
(array to vector, two registers): Move two ZA single-vector groups to two vector registers.
(tile to vector, four registers): Move four ZA tile slices to four vector registers.
(tile to vector, single): Move ZA tile slice to vector register.
(tile to vector, two registers): Move two ZA tile slices to two vector registers.
(vector to array, four registers): Move four vector registers to four ZA single-vector groups.
(vector to array, two registers): Move two vector registers to two ZA single-vector groups.
(vector to tile, four registers): Move four vector registers to four ZA tile slices.
(vector to tile, single): Move vector register to ZA tile slice.
(vector to tile, two registers): Move two vector registers to two ZA tile slices.
The reference can be found here:
https://developer.arm.com/documentation/ddi0602/2022-09
It add more sizes for Matrix Operand:
MatrixOp8 and MatrixOp16
two implicit operands uimm0s2range and uimm0s4range.
and uimm1s2range that are immediates
Differential Revision: https://reviews.llvm.org/D136142
Added:
llvm/test/MC/AArch64/SME2/mova-diagnostics.s
llvm/test/MC/AArch64/SME2/mova.s
Modified:
llvm/lib/Target/AArch64/AArch64InstrFormats.td
llvm/lib/Target/AArch64/AArch64RegisterInfo.td
llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td
llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
llvm/lib/Target/AArch64/SMEInstrFormats.td
Removed:
################################################################################
diff --git a/llvm/lib/Target/AArch64/AArch64InstrFormats.td b/llvm/lib/Target/AArch64/AArch64InstrFormats.td
index b7c1cb6a47831..57293e1123753 100644
--- a/llvm/lib/Target/AArch64/AArch64InstrFormats.td
+++ b/llvm/lib/Target/AArch64/AArch64InstrFormats.td
@@ -1428,11 +1428,39 @@ class UImmScaledMemoryIndexedRange<int Width, int Scale, int OffsetVal> : AsmOpe
let ParserMethod = "tryParseImmRange";
}
+// Implicit immediate ranges 0:1 and 0:3, scale has no meaning
+// since the immediate is zero
+def UImm0s2RangeOperand : UImmScaledMemoryIndexedRange<0, 2, 1>;
+def UImm0s4RangeOperand : UImmScaledMemoryIndexedRange<0, 4, 3>;
+
+def UImm1s2RangeOperand : UImmScaledMemoryIndexedRange<1, 2, 1>;
def UImm1s4RangeOperand : UImmScaledMemoryIndexedRange<1, 4, 3>;
def UImm2s2RangeOperand : UImmScaledMemoryIndexedRange<2, 2, 1>;
def UImm2s4RangeOperand : UImmScaledMemoryIndexedRange<2, 4, 3>;
def UImm3s2RangeOperand : UImmScaledMemoryIndexedRange<3, 2, 1>;
+def uimm0s2range : Operand<i64>, ImmLeaf<i64,
+[{ return Imm == 0; }], UImmS1XForm> {
+ let PrintMethod = "printImmRangeScale<2, 1>";
+ let ParserMatchClass = UImm0s2RangeOperand;
+ let OperandNamespace = "AArch64";
+ let OperandType = "OPERAND_IMPLICIT_IMM_0";
+}
+
+def uimm0s4range : Operand<i64>, ImmLeaf<i64,
+[{ return Imm == 0; }], UImmS1XForm> {
+ let PrintMethod = "printImmRangeScale<4, 3>";
+ let ParserMatchClass = UImm0s4RangeOperand;
+ let OperandNamespace = "AArch64";
+ let OperandType = "OPERAND_IMPLICIT_IMM_0";
+}
+
+def uimm1s2range : Operand<i64>, ImmLeaf<i64,
+[{ return Imm >= 0 && Imm <= 2 && ((Imm % 2) == 0); }], UImmS2XForm> {
+ let PrintMethod = "printImmRangeScale<2, 1>";
+ let ParserMatchClass = UImm1s2RangeOperand;
+}
+
def uimm1s4range : Operand<i64>, ImmLeaf<i64,
[{ return Imm >= 0 && Imm <= 4 && ((Imm % 4) == 0); }], UImmS4XForm> {
let PrintMethod = "printImmRangeScale<4, 3>";
diff --git a/llvm/lib/Target/AArch64/AArch64RegisterInfo.td b/llvm/lib/Target/AArch64/AArch64RegisterInfo.td
index 7b100e9026d06..2fae92ef93ea0 100644
--- a/llvm/lib/Target/AArch64/AArch64RegisterInfo.td
+++ b/llvm/lib/Target/AArch64/AArch64RegisterInfo.td
@@ -1542,6 +1542,8 @@ class MatrixOperand<RegisterClass RC, int EltSize> : RegisterOperand<RC> {
def MatrixOp : MatrixOperand<MPR, 0>;
// SME2 register operands and classes
+def MatrixOp8 : MatrixOperand<MPR, 8>;
+def MatrixOp16 : MatrixOperand<MPR, 16>;
def MatrixOp32 : MatrixOperand<MPR, 32>;
def MatrixOp64 : MatrixOperand<MPR, 64>;
diff --git a/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td b/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td
index 23d034636c4fc..fdb5ff967a45f 100644
--- a/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td
+++ b/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td
@@ -596,6 +596,16 @@ defm FRINTN_2Z2Z: sme2_frint_vector_vg2_multi<"frintn", 0b10000>;
defm FRINTN_4Z4Z: sme2_frint_vector_vg4_multi<"frintn", 0b1000000>;
defm FRINTP_2Z2Z: sme2_frint_vector_vg2_multi<"frintp", 0b10010>;
defm FRINTP_4Z4Z: sme2_frint_vector_vg4_multi<"frintp", 0b1001000>;
+
+defm MOVA_MXI2Z : sme2_mova_vec_to_tile_vg2_multi<"mova">;
+defm MOVA_MXI4Z : sme2_mova_vec_to_tile_vg4_multi<"mova">;
+defm MOVA_2ZMXI : sme2_mova_tile_to_vec_vg2_multi<"mova">;
+defm MOVA_4ZMXI : sme2_mova_tile_to_vec_vg4_multi<"mova">;
+
+defm MOVA_VG2_MXI2Z : sme2_mova_vec_to_array_vg2_multi<"mova">;
+defm MOVA_VG4_MXI4Z : sme2_mova_vec_to_array_vg4_multi<"mova">;
+defm MOVA_VG2_2ZMXI : sme2_mova_array_to_vec_vg2_multi<"mova">;
+defm MOVA_VG4_4ZMXI : sme2_mova_array_to_vec_vg4_multi<"mova">;
}
let Predicates = [HasSME2, HasSMEI16I64] in {
diff --git a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
index cc6bd90b69568..600675df8f1a4 100644
--- a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
+++ b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
@@ -3167,6 +3167,14 @@ AArch64AsmParser::tryParseImmWithOptionalShift(OperandVector &Operands) {
// Eat ','
Lex();
+ StringRef VecGroup;
+ if (!parseOptionalVGOperand(Operands, VecGroup)) {
+ Operands.push_back(
+ AArch64Operand::CreateImm(Imm, S, getLoc(), getContext()));
+ Operands.push_back(
+ AArch64Operand::CreateToken(VecGroup, getLoc(), getContext()));
+ return MatchOperand_Success;
+ }
// The optional operand must be "lsl #N" where N is non-negative.
if (!getTok().is(AsmToken::Identifier) ||
@@ -5570,6 +5578,13 @@ bool AArch64AsmParser::showMatchError(SMLoc Loc, unsigned ErrCode,
return Error(Loc, "immediate must be an integer in range [1, 32].");
case Match_InvalidImm1_64:
return Error(Loc, "immediate must be an integer in range [1, 64].");
+ case Match_InvalidMemoryIndexedRange2UImm0:
+ return Error(Loc, "vector select offset must be the immediate range 0:1.");
+ case Match_InvalidMemoryIndexedRange2UImm1:
+ return Error(Loc, "vector select offset must be an immediate range of the "
+ "form <immf>:<imml>, where the first "
+ "immediate is a multiple of 2 in the range [0, 2], and "
+ "the second immediate is immf + 1.");
case Match_InvalidMemoryIndexedRange2UImm2:
case Match_InvalidMemoryIndexedRange2UImm3:
return Error(
@@ -5579,6 +5594,8 @@ bool AArch64AsmParser::showMatchError(SMLoc Loc, unsigned ErrCode,
"where the first immediate is a multiple of 2 in the range [0, 6] or "
"[0, 14] "
"depending on the instruction, and the second immediate is immf + 1.");
+ case Match_InvalidMemoryIndexedRange4UImm0:
+ return Error(Loc, "vector select offset must be the immediate range 0:3.");
case Match_InvalidMemoryIndexedRange4UImm1:
case Match_InvalidMemoryIndexedRange4UImm2:
return Error(
@@ -5794,6 +5811,10 @@ bool AArch64AsmParser::showMatchError(SMLoc Loc, unsigned ErrCode,
return Error(Loc, "invalid matrix operand, expected za[0-7].d");
case Match_InvalidMatrix:
return Error(Loc, "invalid matrix operand, expected za");
+ case Match_InvalidMatrix8:
+ return Error(Loc, "invalid matrix operand, expected suffix .b");
+ case Match_InvalidMatrix16:
+ return Error(Loc, "invalid matrix operand, expected suffix .h");
case Match_InvalidMatrix32:
return Error(Loc, "invalid matrix operand, expected suffix .s");
case Match_InvalidMatrix64:
@@ -6260,8 +6281,11 @@ bool AArch64AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
case Match_InvalidImm1_16:
case Match_InvalidImm1_32:
case Match_InvalidImm1_64:
+ case Match_InvalidMemoryIndexedRange2UImm0:
+ case Match_InvalidMemoryIndexedRange2UImm1:
case Match_InvalidMemoryIndexedRange2UImm2:
case Match_InvalidMemoryIndexedRange2UImm3:
+ case Match_InvalidMemoryIndexedRange4UImm0:
case Match_InvalidMemoryIndexedRange4UImm1:
case Match_InvalidMemoryIndexedRange4UImm2:
case Match_InvalidSVEAddSubImm8:
@@ -6360,6 +6384,8 @@ bool AArch64AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
case Match_InvalidMatrixTile32:
case Match_InvalidMatrixTile64:
case Match_InvalidMatrix:
+ case Match_InvalidMatrix8:
+ case Match_InvalidMatrix16:
case Match_InvalidMatrix32:
case Match_InvalidMatrix64:
case Match_InvalidMatrixTileVectorH8:
diff --git a/llvm/lib/Target/AArch64/SMEInstrFormats.td b/llvm/lib/Target/AArch64/SMEInstrFormats.td
index 4f2b2d9694ed7..ca35343610751 100644
--- a/llvm/lib/Target/AArch64/SMEInstrFormats.td
+++ b/llvm/lib/Target/AArch64/SMEInstrFormats.td
@@ -2670,3 +2670,902 @@ multiclass sme2_luti4_vector_vg4_index<string mnemonic> {
def _S : sme2_luti4_vector_vg4_index<0b10, ZZZZ_s_mul_r, mnemonic>;
}
+//===----------------------------------------------------------------------===//
+// SME2 MOV
+class sme2_mova_vec_to_tile_vg2_multi_base<bits<2> sz, bit v,
+ RegisterOperand tile_ty,
+ Operand index_ty,
+ RegisterOperand vector_ty,
+ string mnemonic>
+ : I<(outs tile_ty:$ZAd),
+ (ins tile_ty:$_ZAd, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm, vector_ty:$Zn),
+ mnemonic, "\t$ZAd[$Rs, $imm, vgx2], $Zn",
+ "", []>, Sched<[]> {
+ bits<2> Rs;
+ bits<4> Zn;
+ let Inst{31-24} = 0b11000000;
+ let Inst{23-22} = sz;
+ let Inst{21-16} = 0b000100;
+ let Inst{15} = v;
+ let Inst{14-13} = Rs;
+ let Inst{12-10} = 0b000;
+ let Inst{9-6} = Zn;
+ let Inst{5-3} = 0b000;
+
+ let Constraints = "$ZAd = $_ZAd";
+}
+
+multiclass sme2_mova_vec_to_tile_or_array_aliases<int prefer, Instruction inst,
+ RegisterOperand tile_or_array_ty,
+ RegisterOperand rv_ty,
+ Operand index_ty,
+ RegisterOperand vector_ty,
+ string mnemonic,
+ string vg_acronym=""> {
+ def : InstAlias<mnemonic # "\t$ZAd[$Rs, $imm" # !if(!eq(vg_acronym, ""), "", ", " # vg_acronym) # "], $Zn",
+ (inst tile_or_array_ty:$ZAd, rv_ty:$Rs, index_ty:$imm, vector_ty:$Zn), prefer>;
+
+}
+
+// SME2 move vector to tile, two registers
+multiclass sme2_mova_vec_to_tile_vg2_multi_base<bit v, string mnemonic> {
+
+ def _B : sme2_mova_vec_to_tile_vg2_multi_base<0b00, v,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ uimm3s2range, ZZ_b_mul_r,
+ mnemonic> {
+ bits<3> imm;
+ let Inst{2-0} = imm;
+ }
+
+ def _H : sme2_mova_vec_to_tile_vg2_multi_base<0b01, v,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ uimm2s2range, ZZ_h_mul_r,
+ mnemonic> {
+ bits<1> ZAd;
+ bits<2> imm;
+ let Inst{2} = ZAd;
+ let Inst{1-0} = imm;
+ }
+
+ def _S : sme2_mova_vec_to_tile_vg2_multi_base<0b10, v,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ uimm1s2range, ZZ_s_mul_r,
+ mnemonic> {
+ bits<2> ZAd;
+ bits<1> imm;
+ let Inst{2-1} = ZAd;
+ let Inst{0} = imm;
+ }
+
+ def _D : sme2_mova_vec_to_tile_vg2_multi_base<0b11, v,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ uimm0s2range, ZZ_d_mul_r,
+ mnemonic> {
+ bits<3> ZAd;
+ let Inst{2-0} = ZAd;
+ }
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _B),
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm3s2range, ZZ_b_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _H),
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm2s2range, ZZ_h_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _S),
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm1s2range, ZZ_s_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _D),
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s2range, ZZ_d_mul_r,
+ "mov">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _B),
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm3s2range, ZZ_b_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _H),
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm2s2range, ZZ_h_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _S),
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm1s2range, ZZ_s_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _D),
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s2range, ZZ_d_mul_r,
+ "mova">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _B),
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm3s2range, ZZ_b_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _H),
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm2s2range, ZZ_h_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _S),
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm1s2range, ZZ_s_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _D),
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s2range, ZZ_d_mul_r,
+ "mova">;
+}
+
+multiclass sme2_mova_vec_to_tile_vg2_multi<string mnemonic>{
+ defm _H : sme2_mova_vec_to_tile_vg2_multi_base<0b0, mnemonic>;
+ defm _V : sme2_mova_vec_to_tile_vg2_multi_base<0b1, mnemonic>;
+}
+
+class sme2_mova_vec_to_tile_vg4_multi_base<bits<2> sz, bit v, bits<3> op,
+ RegisterOperand tile_ty,
+ Operand index_ty,
+ RegisterOperand vector_ty,
+ string mnemonic>
+ : I<(outs tile_ty:$ZAd),
+ (ins tile_ty:$_ZAd, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm,
+ vector_ty:$Zn),
+ mnemonic,
+ "\t$ZAd[$Rs, $imm, vgx4], $Zn",
+ "", []>, Sched<[]> {
+ bits<2> Rs;
+ bits<3> Zn;
+ let Inst{31-24} = 0b11000000;
+ let Inst{23-22} = sz;
+ let Inst{21-16} = 0b000100;
+ let Inst{15} = v;
+ let Inst{14-13} = Rs;
+ let Inst{12-10} = 0b001;
+ let Inst{9-7} = Zn;
+ let Inst{6-3} = 0b0000;
+ let Inst{2-0} = op;
+ let Constraints = "$ZAd = $_ZAd";
+}
+
+// SME2 move vector to tile, four registers
+multiclass sme2_mova_vec_to_tile_vg4_multi_base<bit v, string mnemonic> {
+
+ def _B : sme2_mova_vec_to_tile_vg4_multi_base<0b00, v, {0,?,?},
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ uimm2s4range, ZZZZ_b_mul_r,
+ mnemonic> {
+ bits<2> imm;
+ let Inst{1-0} = imm;
+ }
+
+ def _H : sme2_mova_vec_to_tile_vg4_multi_base<0b01, v, {0,?,?},
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ uimm1s4range, ZZZZ_h_mul_r,
+ mnemonic> {
+ bits<1> ZAd;
+ bits<1> imm;
+ let Inst{1} = ZAd;
+ let Inst{0} = imm;
+ }
+
+ def _S : sme2_mova_vec_to_tile_vg4_multi_base<0b10, v, {0,?,?},
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ uimm0s4range, ZZZZ_s_mul_r,
+ mnemonic> {
+ bits<2> ZAd;
+ let Inst{1-0} = ZAd;
+ }
+
+ def _D : sme2_mova_vec_to_tile_vg4_multi_base<0b11, v, {?,?,?},
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ uimm0s4range, ZZZZ_d_mul_r,
+ mnemonic> {
+ bits<3> ZAd;
+ let Inst{2-0} = ZAd;
+ }
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _B),
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm2s4range, ZZZZ_b_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _H),
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm1s4range, ZZZZ_h_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _S),
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, ZZZZ_s_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME # _D),
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, ZZZZ_d_mul_r,
+ "mov">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _B),
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm2s4range, ZZZZ_b_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _H),
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm1s4range, ZZZZ_h_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _S),
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, ZZZZ_s_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME # _D),
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, ZZZZ_d_mul_r,
+ "mova">;
+
+}
+
+multiclass sme2_mova_vec_to_tile_vg4_multi<string mnemonic>{
+ defm _H : sme2_mova_vec_to_tile_vg4_multi_base<0b0, mnemonic>;
+ defm _V : sme2_mova_vec_to_tile_vg4_multi_base<0b1, mnemonic>;
+}
+
+// SME Move into Array
+class sme2_mova_vec_to_array_vg24_multi< bits<5> op, RegisterOperand array_ty,
+ RegisterOperand vector_ty,
+ string mnemonic,
+ string vg_acronym="">
+ : I<(outs array_ty:$ZAd),
+ (ins array_ty:$_ZAd, MatrixIndexGPR32Op8_11:$Rs, sme_elm_idx0_7:$imm,
+ vector_ty:$Zn),
+ mnemonic, "\t$ZAd[$Rs, $imm, " # vg_acronym # "], $Zn",
+ "", []>, Sched<[]> {
+ bits<2> Rs;
+ bits<3> imm;
+ let Inst{31-15} = 0b11000000000001000;
+ let Inst{14-13} = Rs;
+ let Inst{12-11} = 0b01;
+ let Inst{10-6} = op;
+ let Inst{5-3} = 0b000;
+ let Inst{2-0} = imm;
+
+ let Constraints = "$ZAd = $_ZAd";
+}
+
+// MOVA (vector to array, two registers)
+multiclass sme2_mova_vec_to_array_vg2_multi<string mnemonic> {
+ def NAME : sme2_mova_vec_to_array_vg24_multi<{0,?,?,?,?}, MatrixOp64,
+ ZZ_d_mul_r, mnemonic, "vgx2">{
+ bits<4> Zn;
+ let Inst{9-6} = Zn;
+ }
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_b_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_h_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_s_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_d_mul_r,
+ "mova">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_b_mul_r,
+ "mova", "vgx2">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_h_mul_r,
+ "mova", "vgx2">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_s_mul_r,
+ "mova", "vgx2">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_b_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_h_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_s_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_d_mul_r,
+ "mov">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_b_mul_r,
+ "mov", "vgx2">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_h_mul_r,
+ "mov", "vgx2">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_s_mul_r,
+ "mov", "vgx2">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME),
+ MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZ_d_mul_r,
+ "mov", "vgx2">;
+}
+
+// MOVA (vector to array, four registers)
+multiclass sme2_mova_vec_to_array_vg4_multi<string mnemonic> {
+ def NAME : sme2_mova_vec_to_array_vg24_multi<{1,?,?,?,0}, MatrixOp64,
+ ZZZZ_d_mul_r, mnemonic, "vgx4"> {
+ bits<3> Zn;
+ let Inst{9-7} = Zn;
+ }
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_b_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_h_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_s_mul_r,
+ "mova">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_d_mul_r,
+ "mova">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_b_mul_r,
+ "mova", "vgx4">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_h_mul_r,
+ "mova", "vgx4">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_s_mul_r,
+ "mova", "vgx4">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_b_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_h_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_s_mul_r,
+ "mov">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_d_mul_r,
+ "mov">;
+
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_b_mul_r,
+ "mov", "vgx4">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_h_mul_r,
+ "mov", "vgx4">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast<Instruction>(NAME),
+ MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_s_mul_r,
+ "mov", "vgx4">;
+ defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast<Instruction>(NAME),
+ MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, ZZZZ_d_mul_r,
+ "mov", "vgx4">;
+
+}
+
+class sme2_mova_tile_to_vec_vg2_multi_base<bits<2> sz, bit v,
+ RegisterOperand vector_ty,
+ RegisterOperand tile_ty,
+ Operand index_ty,
+ string mnemonic>
+ : I<(outs vector_ty:$Zd),
+ (ins tile_ty:$ZAn, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm),
+ mnemonic,
+ "\t$Zd, $ZAn[$Rs, $imm, vgx2]",
+ "", []>, Sched<[]> {
+ bits<4> Zd;
+ bits<2> Rs;
+ let Inst{31-24} = 0b11000000;
+ let Inst{23-22} = sz;
+ let Inst{21-16} = 0b000110;
+ let Inst{15} = v;
+ let Inst{14-13} = Rs;
+ let Inst{12-8} = 0b00000;
+ let Inst{4-1} = Zd;
+ let Inst{0} = 0b0;
+}
+
+multiclass sme2_mova_tile_or_array_to_vec_aliases<int op, Instruction inst,
+ RegisterOperand vector_ty,
+ RegisterOperand tile_or_array_ty,
+ RegisterOperand rv_ty,
+ Operand index_ty,
+ string mnemonic,
+ string vg_acronym=""> {
+def : InstAlias<mnemonic # "\t$Zd, $ZAn[$Rs, $imm" # !if(!eq(vg_acronym, ""), "", ", " # vg_acronym) # "]",
+ (inst vector_ty:$Zd, tile_or_array_ty:$ZAn, rv_ty:$Rs, index_ty:$imm), op>;
+
+}
+
+// SME2 move tile to vector, two registers
+multiclass sme2_mova_tile_to_vec_vg2_multi_inst<bit v, string mnemonic> {
+
+ def _B : sme2_mova_tile_to_vec_vg2_multi_base<0b00, v, ZZ_b_mul_r,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ uimm3s2range, mnemonic> {
+ bits<3> imm;
+ let Inst{7-5} = imm;
+ }
+
+ def _H : sme2_mova_tile_to_vec_vg2_multi_base<0b01, v, ZZ_h_mul_r,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ uimm2s2range, mnemonic> {
+ bits<1> ZAn;
+ bits<2> imm;
+ let Inst{7} = ZAn;
+ let Inst{6-5} = imm;
+ }
+
+ def _S : sme2_mova_tile_to_vec_vg2_multi_base<0b10, v, ZZ_s_mul_r,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ uimm1s2range, mnemonic> {
+ bits<2> ZAn;
+ bits<1> imm;
+ let Inst{7-6} = ZAn;
+ let Inst{5} = imm;
+ }
+
+ def _D : sme2_mova_tile_to_vec_vg2_multi_base<0b11, v, ZZ_d_mul_r,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ uimm0s2range, mnemonic> {
+ bits<3> ZAn;
+ let Inst{7-5} = ZAn;
+ }
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1,!cast<Instruction>(NAME # _B),
+ ZZ_b_mul_r,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm3s2range, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1,!cast<Instruction>(NAME # _H),
+ ZZ_h_mul_r,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm2s2range, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME # _S),
+ ZZ_s_mul_r,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm1s2range, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME # _D),
+ ZZ_d_mul_r,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s2range, "mov">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0,!cast<Instruction>(NAME # _B),
+ ZZ_b_mul_r,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm3s2range, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0,!cast<Instruction>(NAME # _H),
+ ZZ_h_mul_r,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm2s2range, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME # _S),
+ ZZ_s_mul_r,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm1s2range, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME # _D),
+ ZZ_d_mul_r,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s2range, "mova">;
+
+}
+
+multiclass sme2_mova_tile_to_vec_vg2_multi<string mnemonic>{
+ defm _H : sme2_mova_tile_to_vec_vg2_multi_inst<0b0, mnemonic>;
+ defm _V : sme2_mova_tile_to_vec_vg2_multi_inst<0b1, mnemonic>;
+}
+
+// SME2 move tile to vector, four registers
+class sme2_mova_tile_to_vec_vg4_multi_base<bits<2> sz, bit v, bits<3> op,
+ RegisterOperand vector_ty,
+ RegisterOperand tile_ty,
+ Operand index_ty,
+ string mnemonic>
+ : I<(outs vector_ty:$Zd),
+ (ins tile_ty:$ZAn, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm),
+ mnemonic,
+ "\t$Zd, $ZAn[$Rs, $imm, vgx4]",
+ "", []>, Sched<[]> {
+ bits<3> Zd;
+ bits<2> Rs;
+ let Inst{31-24} = 0b11000000;
+ let Inst{23-22} = sz;
+ let Inst{21-16} = 0b000110;
+ let Inst{15} = v;
+ let Inst{14-13} = Rs;
+ let Inst{12-8} = 0b00100;
+ let Inst{7-5} = op;
+ let Inst{4-2} = Zd;
+ let Inst{1-0} = 0b00;
+}
+
+multiclass sme2_mova_tile_to_vec_vg4_multi_base<bit v, string mnemonic> {
+
+ def _B : sme2_mova_tile_to_vec_vg4_multi_base<0b00, v, {0,?,?},
+ ZZZZ_b_mul_r,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ uimm2s4range, mnemonic> {
+ bits<2> imm;
+ let Inst{6-5} = imm;
+ }
+
+ def _H : sme2_mova_tile_to_vec_vg4_multi_base<0b01, v, {0,?,?},
+ ZZZZ_h_mul_r,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ uimm1s4range, mnemonic> {
+ bits<1> ZAn;
+ bits<1> imm;
+ let Inst{6} = ZAn;
+ let Inst{5} = imm;
+ }
+
+ def _S : sme2_mova_tile_to_vec_vg4_multi_base<0b10, v, {0,?,?},
+ ZZZZ_s_mul_r,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ uimm0s4range, mnemonic> {
+ bits<2> ZAn;
+ let Inst{6-5} = ZAn;
+ }
+
+ def _D : sme2_mova_tile_to_vec_vg4_multi_base<0b11, v, {?,?,?},
+ ZZZZ_d_mul_r,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ uimm0s4range, mnemonic> {
+ bits<3> ZAn;
+ let Inst{7-5} = ZAn;
+ }
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME # _B),
+ ZZZZ_b_mul_r,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm2s4range, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME # _H),
+ ZZZZ_h_mul_r,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm1s4range, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME # _S),
+ ZZZZ_s_mul_r,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME # _D),
+ ZZZZ_d_mul_r,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, "mov">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME # _B),
+ ZZZZ_b_mul_r,
+ !if(v, TileVectorOpV8,
+ TileVectorOpH8),
+ MatrixIndexGPR32Op12_15,
+ uimm2s4range, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME # _H),
+ ZZZZ_h_mul_r,
+ !if(v, TileVectorOpV16,
+ TileVectorOpH16),
+ MatrixIndexGPR32Op12_15,
+ uimm1s4range, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME # _S),
+ ZZZZ_s_mul_r,
+ !if(v, TileVectorOpV32,
+ TileVectorOpH32),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME # _D),
+ ZZZZ_d_mul_r,
+ !if(v, TileVectorOpV64,
+ TileVectorOpH64),
+ MatrixIndexGPR32Op12_15,
+ uimm0s4range, "mova">;
+
+}
+multiclass sme2_mova_tile_to_vec_vg4_multi<string mnemonic>{
+ defm _H : sme2_mova_tile_to_vec_vg4_multi_base<0b0, mnemonic>;
+ defm _V : sme2_mova_tile_to_vec_vg4_multi_base<0b1, mnemonic>;
+}
+
+// SME Move from Array
+class sme2_mova_array_to_vec_vg24_multi<bits<4> op, RegisterOperand vector_ty,
+ RegisterOperand array_ty,
+ string mnemonic, string vg_acronym>
+ : I<(outs vector_ty:$Zd),
+ (ins array_ty:$ZAn, MatrixIndexGPR32Op8_11:$Rs, sme_elm_idx0_7:$imm),
+ mnemonic,
+ "\t$Zd, $ZAn[$Rs, $imm, " # vg_acronym # "]",
+ "", []>, Sched<[]> {
+ bits<2> Rs;
+ bits<3> imm;
+ let Inst{31-15} = 0b11000000000001100;
+ let Inst{14-13} = Rs;
+ let Inst{12-11} = 0b01;
+ let Inst{10} = op{3};
+ let Inst{9-8} = op{2-1};
+ let Inst{7-5} = imm;
+ let Inst{1} = op{0};
+ let Inst{0} = 0b0;
+}
+
+// MOVA (array to vector, two registers)
+multiclass sme2_mova_array_to_vec_vg2_multi<string mnemonic> {
+ def NAME : sme2_mova_array_to_vec_vg24_multi<{0b000,?}, ZZ_d_mul_r, MatrixOp64,
+ mnemonic, "vgx2">{
+ bits<4> Zd;
+ let Inst{4-1} = Zd;
+ }
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_d_mul_r, MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova", "vgx2">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova", "vgx2">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova", "vgx2">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_d_mul_r, MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx2">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx2">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx2">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME),
+ ZZ_d_mul_r, MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx2">;
+}
+
+// MOVA (array to vector, four registers)
+multiclass sme2_mova_array_to_vec_vg4_multi<string mnemonic> {
+ def NAME : sme2_mova_array_to_vec_vg24_multi<0b1000, ZZZZ_d_mul_r, MatrixOp64,
+ mnemonic, "vgx4">{
+ bits<3> Zd;
+ let Inst{4-2} = Zd;
+ }
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_d_mul_r, MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova", "vgx4">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova", "vgx4">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mova", "vgx4">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_d_mul_r, MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov">;
+
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_b_mul_r, MatrixOp8,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx4">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_h_mul_r, MatrixOp16,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx4">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast<Instruction>(NAME),
+ ZZZZ_s_mul_r, MatrixOp32,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx4">;
+ defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast<Instruction>(NAME),
+ ZZZZ_d_mul_r, MatrixOp64,
+ MatrixIndexGPR32Op8_11,
+ sme_elm_idx0_7, "mov", "vgx4">;
+}
diff --git a/llvm/test/MC/AArch64/SME2/mova-diagnostics.s b/llvm/test/MC/AArch64/SME2/mova-diagnostics.s
new file mode 100644
index 0000000000000..2839e2f9e26e6
--- /dev/null
+++ b/llvm/test/MC/AArch64/SME2/mova-diagnostics.s
@@ -0,0 +1,73 @@
+// RUN: not llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2 2>&1 < %s | FileCheck %s
+
+// --------------------------------------------------------------------------//
+// Multi-vector sequence constraints
+
+mova {z1.d-z2.d}, za.d[w12]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: Invalid vector list, expected list with 2 consecutive SVE vectors, where the first vector is a multiple of 2 and with matching element types
+// CHECK-NEXT: mova {z1.d-z2.d}, za.d[w12]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mova {z1.d-z4.d}, za.d[w12]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: Invalid vector list, expected list with 4 consecutive SVE vectors, where the first vector is a multiple of 4 and with matching element types
+// CHECK-NEXT: mova {z1.d-z4.d}, za.d[w12]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+// --------------------------------------------------------------------------//
+// Invalid index offset
+
+mova {z0.s, z1.s}, za0h.s[w12, 1:2]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: vector select offset must be an immediate range of the form <immf>:<imml>, where the first immediate is a multiple of 2 in the range [0, 2], and the second immediate is immf + 1.
+// CHECK-NEXT: mova {z0.s, z1.s}, za0h.s[w12, 1:2]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mova {z0.s, z1.s}, za0h.s[w12, 3:4]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: vector select offset must be an immediate range of the form <immf>:<imml>, where the first immediate is a multiple of 2 in the range [0, 2], and the second immediate is immf + 1.
+// CHECK-NEXT: mova {z0.s, z1.s}, za0h.s[w12, 3:4]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mova {z0.s, z1.s}, za0h.s[w12, 0:2]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction
+// CHECK-NEXT: mova {z0.s, z1.s}, za0h.s[w12, 0:2]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mova {z20.d-z21.d}, za2h.d[w14, 0:3]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction
+// CHECK-NEXT: mova {z20.d-z21.d}, za2h.d[w14, 0:3]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mova {z16.s-z19.s}, za1h.s[w14, 0:1]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction
+// CHECK-NEXT: mova {z16.s-z19.s}, za1h.s[w14, 0:1]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+// --------------------------------------------------------------------------//
+// Invalid index (expected range)
+
+mova {z0.b-z3.b}, za0h.b[w13, 0]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction
+// CHECK-NEXT: mova {z0.b-z3.b}, za0h.b[w13, 0]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+// --------------------------------------------------------------------------//
+// Operands are not consistent
+
+mova za.h[w8, 0], {z0.s-z3.s}
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction
+// CHECK-NEXT: mova za.h[w8, 0], {z0.s-z3.s}
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mov za.h[w8, 0], {z0.s-z3.s}
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction
+// CHECK-NEXT:mov za.h[w8, 0], {z0.s-z3.s}
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mova {z0.s-z3.s}, za.b[w8, 0]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid matrix operand, expected suffix .s
+// CHECK-NEXT: mova {z0.s-z3.s}, za.b[w8, 0]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
+
+mov {z0.h-z3.h}, za.d[w8, 0]
+// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid matrix operand, expected suffix .h
+// CHECK-NEXT: mov {z0.h-z3.h}, za.d[w8, 0]
+// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}:
diff --git a/llvm/test/MC/AArch64/SME2/mova.s b/llvm/test/MC/AArch64/SME2/mova.s
new file mode 100644
index 0000000000000..a2c6469e19afa
--- /dev/null
+++ b/llvm/test/MC/AArch64/SME2/mova.s
@@ -0,0 +1,5521 @@
+// RUN: llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2 < %s \
+// RUN: | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+// RUN: not llvm-mc -triple=aarch64 -show-encoding < %s 2>&1 \
+// RUN: | FileCheck %s --check-prefix=CHECK-ERROR
+// RUN: llvm-mc -triple=aarch64 -filetype=obj -mattr=+sme2 < %s \
+// RUN: | llvm-objdump --no-print-imm-hex -d --mattr=+sme2 - | FileCheck %s --check-prefix=CHECK-INST
+// RUN: llvm-mc -triple=aarch64 -filetype=obj -mattr=+sme2 < %s \
+// RUN: | llvm-objdump --no-print-imm-hex -d --mattr=-sme2 - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+// RUN: llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2 < %s \
+// RUN: | sed '/.text/d' | sed 's/.*encoding: //g' \
+// RUN: | llvm-mc -triple=aarch64 -mattr=+sme2 -disassemble -show-encoding \
+// RUN: | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+
+
+mova {z0.h, z1.h}, za0h.h[w12, 0:1] // 11000000-01000110-00000000-00000000
+// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460000 <unknown>
+
+mova {z20.h, z21.h}, za0h.h[w14, 4:5] // 11000000-01000110-01000000-01010100
+// CHECK-INST: mov { z20.h, z21.h }, za0h.h[w14, 4:5]
+// CHECK-ENCODING: [0x54,0x40,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464054 <unknown>
+
+mova {z22.h, z23.h}, za1h.h[w15, 2:3] // 11000000-01000110-01100000-10110110
+// CHECK-INST: mov { z22.h, z23.h }, za1h.h[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0x60,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04660b6 <unknown>
+
+mova {z30.h, z31.h}, za1h.h[w15, 6:7] // 11000000-01000110-01100000-11111110
+// CHECK-INST: mov { z30.h, z31.h }, za1h.h[w15, 6:7]
+// CHECK-ENCODING: [0xfe,0x60,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04660fe <unknown>
+
+mova {z4.h, z5.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100100
+// CHECK-INST: mov { z4.h, z5.h }, za0h.h[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460024 <unknown>
+
+mova {z0.h, z1.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100000
+// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460020 <unknown>
+
+mova {z24.h, z25.h}, za0h.h[w14, 6:7] // 11000000-01000110-01000000-01111000
+// CHECK-INST: mov { z24.h, z25.h }, za0h.h[w14, 6:7]
+// CHECK-ENCODING: [0x78,0x40,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464078 <unknown>
+
+mova {z0.h, z1.h}, za1h.h[w12, 0:1] // 11000000-01000110-00000000-10000000
+// CHECK-INST: mov { z0.h, z1.h }, za1h.h[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460080 <unknown>
+
+mova {z16.h, z17.h}, za0h.h[w14, 2:3] // 11000000-01000110-01000000-00110000
+// CHECK-INST: mov { z16.h, z17.h }, za0h.h[w14, 2:3]
+// CHECK-ENCODING: [0x30,0x40,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464030 <unknown>
+
+mova {z28.h, z29.h}, za1h.h[w12, 4:5] // 11000000-01000110-00000000-11011100
+// CHECK-INST: mov { z28.h, z29.h }, za1h.h[w12, 4:5]
+// CHECK-ENCODING: [0xdc,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04600dc <unknown>
+
+mova {z2.h, z3.h}, za0h.h[w15, 2:3] // 11000000-01000110-01100000-00100010
+// CHECK-INST: mov { z2.h, z3.h }, za0h.h[w15, 2:3]
+// CHECK-ENCODING: [0x22,0x60,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0466022 <unknown>
+
+mova {z6.h, z7.h}, za1h.h[w13, 0:1] // 11000000-01000110-00100000-10000110
+// CHECK-INST: mov { z6.h, z7.h }, za1h.h[w13, 0:1]
+// CHECK-ENCODING: [0x86,0x20,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0462086 <unknown>
+
+// Aliases
+
+mov {z0.h, z1.h}, za0h.h[w12, 0:1] // 11000000-01000110-00000000-00000000
+// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460000 <unknown>
+
+mov {z20.h, z21.h}, za0h.h[w14, 4:5] // 11000000-01000110-01000000-01010100
+// CHECK-INST: mov { z20.h, z21.h }, za0h.h[w14, 4:5]
+// CHECK-ENCODING: [0x54,0x40,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464054 <unknown>
+
+mov {z22.h, z23.h}, za1h.h[w15, 2:3] // 11000000-01000110-01100000-10110110
+// CHECK-INST: mov { z22.h, z23.h }, za1h.h[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0x60,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04660b6 <unknown>
+
+mov {z30.h, z31.h}, za1h.h[w15, 6:7] // 11000000-01000110-01100000-11111110
+// CHECK-INST: mov { z30.h, z31.h }, za1h.h[w15, 6:7]
+// CHECK-ENCODING: [0xfe,0x60,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04660fe <unknown>
+
+mov {z4.h, z5.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100100
+// CHECK-INST: mov { z4.h, z5.h }, za0h.h[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460024 <unknown>
+
+mov {z0.h, z1.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100000
+// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460020 <unknown>
+
+mov {z24.h, z25.h}, za0h.h[w14, 6:7] // 11000000-01000110-01000000-01111000
+// CHECK-INST: mov { z24.h, z25.h }, za0h.h[w14, 6:7]
+// CHECK-ENCODING: [0x78,0x40,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464078 <unknown>
+
+mov {z0.h, z1.h}, za1h.h[w12, 0:1] // 11000000-01000110-00000000-10000000
+// CHECK-INST: mov { z0.h, z1.h }, za1h.h[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460080 <unknown>
+
+mov {z16.h, z17.h}, za0h.h[w14, 2:3] // 11000000-01000110-01000000-00110000
+// CHECK-INST: mov { z16.h, z17.h }, za0h.h[w14, 2:3]
+// CHECK-ENCODING: [0x30,0x40,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464030 <unknown>
+
+mov {z28.h, z29.h}, za1h.h[w12, 4:5] // 11000000-01000110-00000000-11011100
+// CHECK-INST: mov { z28.h, z29.h }, za1h.h[w12, 4:5]
+// CHECK-ENCODING: [0xdc,0x00,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04600dc <unknown>
+
+mov {z2.h, z3.h}, za0h.h[w15, 2:3] // 11000000-01000110-01100000-00100010
+// CHECK-INST: mov { z2.h, z3.h }, za0h.h[w15, 2:3]
+// CHECK-ENCODING: [0x22,0x60,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0466022 <unknown>
+
+mov {z6.h, z7.h}, za1h.h[w13, 0:1] // 11000000-01000110-00100000-10000110
+// CHECK-INST: mov { z6.h, z7.h }, za1h.h[w13, 0:1]
+// CHECK-ENCODING: [0x86,0x20,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0462086 <unknown>
+
+
+mova {z0.h, z1.h}, za0v.h[w12, 0:1] // 11000000-01000110-10000000-00000000
+// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468000 <unknown>
+
+mova {z20.h, z21.h}, za0v.h[w14, 4:5] // 11000000-01000110-11000000-01010100
+// CHECK-INST: mov { z20.h, z21.h }, za0v.h[w14, 4:5]
+// CHECK-ENCODING: [0x54,0xc0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c054 <unknown>
+
+mova {z22.h, z23.h}, za1v.h[w15, 2:3] // 11000000-01000110-11100000-10110110
+// CHECK-INST: mov { z22.h, z23.h }, za1v.h[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0xe0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e0b6 <unknown>
+
+mova {z30.h, z31.h}, za1v.h[w15, 6:7] // 11000000-01000110-11100000-11111110
+// CHECK-INST: mov { z30.h, z31.h }, za1v.h[w15, 6:7]
+// CHECK-ENCODING: [0xfe,0xe0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e0fe <unknown>
+
+mova {z4.h, z5.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100100
+// CHECK-INST: mov { z4.h, z5.h }, za0v.h[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468024 <unknown>
+
+mova {z0.h, z1.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100000
+// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468020 <unknown>
+
+mova {z24.h, z25.h}, za0v.h[w14, 6:7] // 11000000-01000110-11000000-01111000
+// CHECK-INST: mov { z24.h, z25.h }, za0v.h[w14, 6:7]
+// CHECK-ENCODING: [0x78,0xc0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c078 <unknown>
+
+mova {z0.h, z1.h}, za1v.h[w12, 0:1] // 11000000-01000110-10000000-10000000
+// CHECK-INST: mov { z0.h, z1.h }, za1v.h[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468080 <unknown>
+
+mova {z16.h, z17.h}, za0v.h[w14, 2:3] // 11000000-01000110-11000000-00110000
+// CHECK-INST: mov { z16.h, z17.h }, za0v.h[w14, 2:3]
+// CHECK-ENCODING: [0x30,0xc0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c030 <unknown>
+
+mova {z28.h, z29.h}, za1v.h[w12, 4:5] // 11000000-01000110-10000000-11011100
+// CHECK-INST: mov { z28.h, z29.h }, za1v.h[w12, 4:5]
+// CHECK-ENCODING: [0xdc,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04680dc <unknown>
+
+mova {z2.h, z3.h}, za0v.h[w15, 2:3] // 11000000-01000110-11100000-00100010
+// CHECK-INST: mov { z2.h, z3.h }, za0v.h[w15, 2:3]
+// CHECK-ENCODING: [0x22,0xe0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e022 <unknown>
+
+mova {z6.h, z7.h}, za1v.h[w13, 0:1] // 11000000-01000110-10100000-10000110
+// CHECK-INST: mov { z6.h, z7.h }, za1v.h[w13, 0:1]
+// CHECK-ENCODING: [0x86,0xa0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046a086 <unknown>
+
+// Aliases
+
+mov {z0.h, z1.h}, za0v.h[w12, 0:1] // 11000000-01000110-10000000-00000000
+// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468000 <unknown>
+
+mov {z20.h, z21.h}, za0v.h[w14, 4:5] // 11000000-01000110-11000000-01010100
+// CHECK-INST: mov { z20.h, z21.h }, za0v.h[w14, 4:5]
+// CHECK-ENCODING: [0x54,0xc0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c054 <unknown>
+
+mov {z22.h, z23.h}, za1v.h[w15, 2:3] // 11000000-01000110-11100000-10110110
+// CHECK-INST: mov { z22.h, z23.h }, za1v.h[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0xe0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e0b6 <unknown>
+
+mov {z30.h, z31.h}, za1v.h[w15, 6:7] // 11000000-01000110-11100000-11111110
+// CHECK-INST: mov { z30.h, z31.h }, za1v.h[w15, 6:7]
+// CHECK-ENCODING: [0xfe,0xe0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e0fe <unknown>
+
+mov {z4.h, z5.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100100
+// CHECK-INST: mov { z4.h, z5.h }, za0v.h[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468024 <unknown>
+
+mov {z0.h, z1.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100000
+// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468020 <unknown>
+
+mov {z24.h, z25.h}, za0v.h[w14, 6:7] // 11000000-01000110-11000000-01111000
+// CHECK-INST: mov { z24.h, z25.h }, za0v.h[w14, 6:7]
+// CHECK-ENCODING: [0x78,0xc0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c078 <unknown>
+
+mov {z0.h, z1.h}, za1v.h[w12, 0:1] // 11000000-01000110-10000000-10000000
+// CHECK-INST: mov { z0.h, z1.h }, za1v.h[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468080 <unknown>
+
+mov {z16.h, z17.h}, za0v.h[w14, 2:3] // 11000000-01000110-11000000-00110000
+// CHECK-INST: mov { z16.h, z17.h }, za0v.h[w14, 2:3]
+// CHECK-ENCODING: [0x30,0xc0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c030 <unknown>
+
+mov {z28.h, z29.h}, za1v.h[w12, 4:5] // 11000000-01000110-10000000-11011100
+// CHECK-INST: mov { z28.h, z29.h }, za1v.h[w12, 4:5]
+// CHECK-ENCODING: [0xdc,0x80,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04680dc <unknown>
+
+mov {z2.h, z3.h}, za0v.h[w15, 2:3] // 11000000-01000110-11100000-00100010
+// CHECK-INST: mov { z2.h, z3.h }, za0v.h[w15, 2:3]
+// CHECK-ENCODING: [0x22,0xe0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e022 <unknown>
+
+mov {z6.h, z7.h}, za1v.h[w13, 0:1] // 11000000-01000110-10100000-10000110
+// CHECK-INST: mov { z6.h, z7.h }, za1v.h[w13, 0:1]
+// CHECK-ENCODING: [0x86,0xa0,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046a086 <unknown>
+
+
+mova za0h.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-00000000-00000000
+// CHECK-INST: mov za0h.h[w12, 0:1], { z0.h, z1.h }
+// CHECK-ENCODING: [0x00,0x00,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440000 <unknown>
+
+mova za1h.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-01000001-01000101
+// CHECK-INST: mov za1h.h[w14, 2:3], { z10.h, z11.h }
+// CHECK-ENCODING: [0x45,0x41,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444145 <unknown>
+
+mova za1h.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-01100001-10000111
+// CHECK-INST: mov za1h.h[w15, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0x61,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446187 <unknown>
+
+mova za1h.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-01100011-11000111
+// CHECK-INST: mov za1h.h[w15, 6:7], { z30.h, z31.h }
+// CHECK-ENCODING: [0xc7,0x63,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04463c7 <unknown>
+
+mova za1h.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-00000010-00000101
+// CHECK-INST: mov za1h.h[w12, 2:3], { z16.h, z17.h }
+// CHECK-ENCODING: [0x05,0x02,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440205 <unknown>
+
+mova za0h.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-00000000-00000001
+// CHECK-INST: mov za0h.h[w12, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0x00,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440001 <unknown>
+
+mova za0h.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-01000010-01000000
+// CHECK-INST: mov za0h.h[w14, 0:1], { z18.h, z19.h }
+// CHECK-ENCODING: [0x40,0x42,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444240 <unknown>
+
+mova za0h.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-00000001-10000000
+// CHECK-INST: mov za0h.h[w12, 0:1], { z12.h, z13.h }
+// CHECK-ENCODING: [0x80,0x01,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440180 <unknown>
+
+mova za0h.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-01000000-00000001
+// CHECK-INST: mov za0h.h[w14, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0x40,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444001 <unknown>
+
+mova za1h.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-00000010-11000101
+// CHECK-INST: mov za1h.h[w12, 2:3], { z22.h, z23.h }
+// CHECK-ENCODING: [0xc5,0x02,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04402c5 <unknown>
+
+mova za0h.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-01100001-00000010
+// CHECK-INST: mov za0h.h[w15, 4:5], { z8.h, z9.h }
+// CHECK-ENCODING: [0x02,0x61,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446102 <unknown>
+
+mova za1h.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-00100001-10000111
+// CHECK-INST: mov za1h.h[w13, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0x21,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0442187 <unknown>
+
+// Aliases
+
+mov za0h.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-00000000-00000000
+// CHECK-INST: mov za0h.h[w12, 0:1], { z0.h, z1.h }
+// CHECK-ENCODING: [0x00,0x00,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440000 <unknown>
+
+mov za1h.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-01000001-01000101
+// CHECK-INST: mov za1h.h[w14, 2:3], { z10.h, z11.h }
+// CHECK-ENCODING: [0x45,0x41,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444145 <unknown>
+
+mov za1h.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-01100001-10000111
+// CHECK-INST: mov za1h.h[w15, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0x61,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446187 <unknown>
+
+mov za1h.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-01100011-11000111
+// CHECK-INST: mov za1h.h[w15, 6:7], { z30.h, z31.h }
+// CHECK-ENCODING: [0xc7,0x63,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04463c7 <unknown>
+
+mov za1h.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-00000010-00000101
+// CHECK-INST: mov za1h.h[w12, 2:3], { z16.h, z17.h }
+// CHECK-ENCODING: [0x05,0x02,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440205 <unknown>
+
+mov za0h.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-00000000-00000001
+// CHECK-INST: mov za0h.h[w12, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0x00,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440001 <unknown>
+
+mov za0h.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-01000010-01000000
+// CHECK-INST: mov za0h.h[w14, 0:1], { z18.h, z19.h }
+// CHECK-ENCODING: [0x40,0x42,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444240 <unknown>
+
+mov za0h.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-00000001-10000000
+// CHECK-INST: mov za0h.h[w12, 0:1], { z12.h, z13.h }
+// CHECK-ENCODING: [0x80,0x01,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440180 <unknown>
+
+mov za0h.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-01000000-00000001
+// CHECK-INST: mov za0h.h[w14, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0x40,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444001 <unknown>
+
+mov za1h.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-00000010-11000101
+// CHECK-INST: mov za1h.h[w12, 2:3], { z22.h, z23.h }
+// CHECK-ENCODING: [0xc5,0x02,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04402c5 <unknown>
+
+mov za0h.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-01100001-00000010
+// CHECK-INST: mov za0h.h[w15, 4:5], { z8.h, z9.h }
+// CHECK-ENCODING: [0x02,0x61,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446102 <unknown>
+
+mov za1h.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-00100001-10000111
+// CHECK-INST: mov za1h.h[w13, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0x21,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0442187 <unknown>
+
+
+mova za0v.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-10000000-00000000
+// CHECK-INST: mov za0v.h[w12, 0:1], { z0.h, z1.h }
+// CHECK-ENCODING: [0x00,0x80,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448000 <unknown>
+
+mova za1v.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-11000001-01000101
+// CHECK-INST: mov za1v.h[w14, 2:3], { z10.h, z11.h }
+// CHECK-ENCODING: [0x45,0xc1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c145 <unknown>
+
+mova za1v.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-11100001-10000111
+// CHECK-INST: mov za1v.h[w15, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0xe1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e187 <unknown>
+
+mova za1v.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-11100011-11000111
+// CHECK-INST: mov za1v.h[w15, 6:7], { z30.h, z31.h }
+// CHECK-ENCODING: [0xc7,0xe3,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e3c7 <unknown>
+
+mova za1v.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-10000010-00000101
+// CHECK-INST: mov za1v.h[w12, 2:3], { z16.h, z17.h }
+// CHECK-ENCODING: [0x05,0x82,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448205 <unknown>
+
+mova za0v.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-10000000-00000001
+// CHECK-INST: mov za0v.h[w12, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0x80,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448001 <unknown>
+
+mova za0v.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-11000010-01000000
+// CHECK-INST: mov za0v.h[w14, 0:1], { z18.h, z19.h }
+// CHECK-ENCODING: [0x40,0xc2,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c240 <unknown>
+
+mova za0v.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-10000001-10000000
+// CHECK-INST: mov za0v.h[w12, 0:1], { z12.h, z13.h }
+// CHECK-ENCODING: [0x80,0x81,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448180 <unknown>
+
+mova za0v.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-11000000-00000001
+// CHECK-INST: mov za0v.h[w14, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0xc0,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c001 <unknown>
+
+mova za1v.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-10000010-11000101
+// CHECK-INST: mov za1v.h[w12, 2:3], { z22.h, z23.h }
+// CHECK-ENCODING: [0xc5,0x82,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04482c5 <unknown>
+
+mova za0v.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-11100001-00000010
+// CHECK-INST: mov za0v.h[w15, 4:5], { z8.h, z9.h }
+// CHECK-ENCODING: [0x02,0xe1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e102 <unknown>
+
+mova za1v.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-10100001-10000111
+// CHECK-INST: mov za1v.h[w13, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0xa1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044a187 <unknown>
+
+// Aliases
+
+mov za0v.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-10000000-00000000
+// CHECK-INST: mov za0v.h[w12, 0:1], { z0.h, z1.h }
+// CHECK-ENCODING: [0x00,0x80,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448000 <unknown>
+
+mov za1v.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-11000001-01000101
+// CHECK-INST: mov za1v.h[w14, 2:3], { z10.h, z11.h }
+// CHECK-ENCODING: [0x45,0xc1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c145 <unknown>
+
+mov za1v.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-11100001-10000111
+// CHECK-INST: mov za1v.h[w15, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0xe1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e187 <unknown>
+
+mov za1v.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-11100011-11000111
+// CHECK-INST: mov za1v.h[w15, 6:7], { z30.h, z31.h }
+// CHECK-ENCODING: [0xc7,0xe3,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e3c7 <unknown>
+
+mov za1v.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-10000010-00000101
+// CHECK-INST: mov za1v.h[w12, 2:3], { z16.h, z17.h }
+// CHECK-ENCODING: [0x05,0x82,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448205 <unknown>
+
+mov za0v.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-10000000-00000001
+// CHECK-INST: mov za0v.h[w12, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0x80,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448001 <unknown>
+
+mov za0v.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-11000010-01000000
+// CHECK-INST: mov za0v.h[w14, 0:1], { z18.h, z19.h }
+// CHECK-ENCODING: [0x40,0xc2,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c240 <unknown>
+
+mov za0v.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-10000001-10000000
+// CHECK-INST: mov za0v.h[w12, 0:1], { z12.h, z13.h }
+// CHECK-ENCODING: [0x80,0x81,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448180 <unknown>
+
+mov za0v.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-11000000-00000001
+// CHECK-INST: mov za0v.h[w14, 2:3], { z0.h, z1.h }
+// CHECK-ENCODING: [0x01,0xc0,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c001 <unknown>
+
+mov za1v.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-10000010-11000101
+// CHECK-INST: mov za1v.h[w12, 2:3], { z22.h, z23.h }
+// CHECK-ENCODING: [0xc5,0x82,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c04482c5 <unknown>
+
+mov za0v.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-11100001-00000010
+// CHECK-INST: mov za0v.h[w15, 4:5], { z8.h, z9.h }
+// CHECK-ENCODING: [0x02,0xe1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e102 <unknown>
+
+mov za1v.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-10100001-10000111
+// CHECK-INST: mov za1v.h[w13, 6:7], { z12.h, z13.h }
+// CHECK-ENCODING: [0x87,0xa1,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044a187 <unknown>
+
+
+mova {z0.s, z1.s}, za0h.s[w12, 0:1] // 11000000-10000110-00000000-00000000
+// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860000 <unknown>
+
+mova {z20.s, z21.s}, za1h.s[w14, 0:1] // 11000000-10000110-01000000-01010100
+// CHECK-INST: mov { z20.s, z21.s }, za1h.s[w14, 0:1]
+// CHECK-ENCODING: [0x54,0x40,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864054 <unknown>
+
+mova {z22.s, z23.s}, za2h.s[w15, 2:3] // 11000000-10000110-01100000-10110110
+// CHECK-INST: mov { z22.s, z23.s }, za2h.s[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0x60,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08660b6 <unknown>
+
+mova {z30.s, z31.s}, za3h.s[w15, 2:3] // 11000000-10000110-01100000-11111110
+// CHECK-INST: mov { z30.s, z31.s }, za3h.s[w15, 2:3]
+// CHECK-ENCODING: [0xfe,0x60,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08660fe <unknown>
+
+mova {z4.s, z5.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100100
+// CHECK-INST: mov { z4.s, z5.s }, za0h.s[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860024 <unknown>
+
+mova {z0.s, z1.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100000
+// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860020 <unknown>
+
+mova {z24.s, z25.s}, za1h.s[w14, 2:3] // 11000000-10000110-01000000-01111000
+// CHECK-INST: mov { z24.s, z25.s }, za1h.s[w14, 2:3]
+// CHECK-ENCODING: [0x78,0x40,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864078 <unknown>
+
+mova {z0.s, z1.s}, za2h.s[w12, 0:1] // 11000000-10000110-00000000-10000000
+// CHECK-INST: mov { z0.s, z1.s }, za2h.s[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860080 <unknown>
+
+mova {z16.s, z17.s}, za0h.s[w14, 2:3] // 11000000-10000110-01000000-00110000
+// CHECK-INST: mov { z16.s, z17.s }, za0h.s[w14, 2:3]
+// CHECK-ENCODING: [0x30,0x40,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864030 <unknown>
+
+mova {z28.s, z29.s}, za3h.s[w12, 0:1] // 11000000-10000110-00000000-11011100
+// CHECK-INST: mov { z28.s, z29.s }, za3h.s[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08600dc <unknown>
+
+mova {z2.s, z3.s}, za0h.s[w15, 2:3] // 11000000-10000110-01100000-00100010
+// CHECK-INST: mov { z2.s, z3.s }, za0h.s[w15, 2:3]
+// CHECK-ENCODING: [0x22,0x60,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0866022 <unknown>
+
+mova {z6.s, z7.s}, za2h.s[w13, 0:1] // 11000000-10000110-00100000-10000110
+// CHECK-INST: mov { z6.s, z7.s }, za2h.s[w13, 0:1]
+// CHECK-ENCODING: [0x86,0x20,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0862086 <unknown>
+
+// Aliases
+
+mov {z0.s, z1.s}, za0h.s[w12, 0:1] // 11000000-10000110-00000000-00000000
+// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860000 <unknown>
+
+mov {z20.s, z21.s}, za1h.s[w14, 0:1] // 11000000-10000110-01000000-01010100
+// CHECK-INST: mov { z20.s, z21.s }, za1h.s[w14, 0:1]
+// CHECK-ENCODING: [0x54,0x40,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864054 <unknown>
+
+mov {z22.s, z23.s}, za2h.s[w15, 2:3] // 11000000-10000110-01100000-10110110
+// CHECK-INST: mov { z22.s, z23.s }, za2h.s[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0x60,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08660b6 <unknown>
+
+mov {z30.s, z31.s}, za3h.s[w15, 2:3] // 11000000-10000110-01100000-11111110
+// CHECK-INST: mov { z30.s, z31.s }, za3h.s[w15, 2:3]
+// CHECK-ENCODING: [0xfe,0x60,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08660fe <unknown>
+
+mov {z4.s, z5.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100100
+// CHECK-INST: mov { z4.s, z5.s }, za0h.s[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860024 <unknown>
+
+mov {z0.s, z1.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100000
+// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860020 <unknown>
+
+mov {z24.s, z25.s}, za1h.s[w14, 2:3] // 11000000-10000110-01000000-01111000
+// CHECK-INST: mov { z24.s, z25.s }, za1h.s[w14, 2:3]
+// CHECK-ENCODING: [0x78,0x40,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864078 <unknown>
+
+mov {z0.s, z1.s}, za2h.s[w12, 0:1] // 11000000-10000110-00000000-10000000
+// CHECK-INST: mov { z0.s, z1.s }, za2h.s[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860080 <unknown>
+
+mov {z16.s, z17.s}, za0h.s[w14, 2:3] // 11000000-10000110-01000000-00110000
+// CHECK-INST: mov { z16.s, z17.s }, za0h.s[w14, 2:3]
+// CHECK-ENCODING: [0x30,0x40,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864030 <unknown>
+
+mov {z28.s, z29.s}, za3h.s[w12, 0:1] // 11000000-10000110-00000000-11011100
+// CHECK-INST: mov { z28.s, z29.s }, za3h.s[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x00,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08600dc <unknown>
+
+mov {z2.s, z3.s}, za0h.s[w15, 2:3] // 11000000-10000110-01100000-00100010
+// CHECK-INST: mov { z2.s, z3.s }, za0h.s[w15, 2:3]
+// CHECK-ENCODING: [0x22,0x60,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0866022 <unknown>
+
+mov {z6.s, z7.s}, za2h.s[w13, 0:1] // 11000000-10000110-00100000-10000110
+// CHECK-INST: mov { z6.s, z7.s }, za2h.s[w13, 0:1]
+// CHECK-ENCODING: [0x86,0x20,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0862086 <unknown>
+
+
+mova {z0.s, z1.s}, za0v.s[w12, 0:1] // 11000000-10000110-10000000-00000000
+// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868000 <unknown>
+
+mova {z20.s, z21.s}, za1v.s[w14, 0:1] // 11000000-10000110-11000000-01010100
+// CHECK-INST: mov { z20.s, z21.s }, za1v.s[w14, 0:1]
+// CHECK-ENCODING: [0x54,0xc0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c054 <unknown>
+
+mova {z22.s, z23.s}, za2v.s[w15, 2:3] // 11000000-10000110-11100000-10110110
+// CHECK-INST: mov { z22.s, z23.s }, za2v.s[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0xe0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e0b6 <unknown>
+
+mova {z30.s, z31.s}, za3v.s[w15, 2:3] // 11000000-10000110-11100000-11111110
+// CHECK-INST: mov { z30.s, z31.s }, za3v.s[w15, 2:3]
+// CHECK-ENCODING: [0xfe,0xe0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e0fe <unknown>
+
+mova {z4.s, z5.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100100
+// CHECK-INST: mov { z4.s, z5.s }, za0v.s[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868024 <unknown>
+
+mova {z0.s, z1.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100000
+// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868020 <unknown>
+
+mova {z24.s, z25.s}, za1v.s[w14, 2:3] // 11000000-10000110-11000000-01111000
+// CHECK-INST: mov { z24.s, z25.s }, za1v.s[w14, 2:3]
+// CHECK-ENCODING: [0x78,0xc0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c078 <unknown>
+
+mova {z0.s, z1.s}, za2v.s[w12, 0:1] // 11000000-10000110-10000000-10000000
+// CHECK-INST: mov { z0.s, z1.s }, za2v.s[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868080 <unknown>
+
+mova {z16.s, z17.s}, za0v.s[w14, 2:3] // 11000000-10000110-11000000-00110000
+// CHECK-INST: mov { z16.s, z17.s }, za0v.s[w14, 2:3]
+// CHECK-ENCODING: [0x30,0xc0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c030 <unknown>
+
+mova {z28.s, z29.s}, za3v.s[w12, 0:1] // 11000000-10000110-10000000-11011100
+// CHECK-INST: mov { z28.s, z29.s }, za3v.s[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08680dc <unknown>
+
+mova {z2.s, z3.s}, za0v.s[w15, 2:3] // 11000000-10000110-11100000-00100010
+// CHECK-INST: mov { z2.s, z3.s }, za0v.s[w15, 2:3]
+// CHECK-ENCODING: [0x22,0xe0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e022 <unknown>
+
+mova {z6.s, z7.s}, za2v.s[w13, 0:1] // 11000000-10000110-10100000-10000110
+// CHECK-INST: mov { z6.s, z7.s }, za2v.s[w13, 0:1]
+// CHECK-ENCODING: [0x86,0xa0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086a086 <unknown>
+
+// Aliases
+
+mov {z0.s, z1.s}, za0v.s[w12, 0:1] // 11000000-10000110-10000000-00000000
+// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868000 <unknown>
+
+mov {z20.s, z21.s}, za1v.s[w14, 0:1] // 11000000-10000110-11000000-01010100
+// CHECK-INST: mov { z20.s, z21.s }, za1v.s[w14, 0:1]
+// CHECK-ENCODING: [0x54,0xc0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c054 <unknown>
+
+mov {z22.s, z23.s}, za2v.s[w15, 2:3] // 11000000-10000110-11100000-10110110
+// CHECK-INST: mov { z22.s, z23.s }, za2v.s[w15, 2:3]
+// CHECK-ENCODING: [0xb6,0xe0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e0b6 <unknown>
+
+mov {z30.s, z31.s}, za3v.s[w15, 2:3] // 11000000-10000110-11100000-11111110
+// CHECK-INST: mov { z30.s, z31.s }, za3v.s[w15, 2:3]
+// CHECK-ENCODING: [0xfe,0xe0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e0fe <unknown>
+
+mov {z4.s, z5.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100100
+// CHECK-INST: mov { z4.s, z5.s }, za0v.s[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868024 <unknown>
+
+mov {z0.s, z1.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100000
+// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868020 <unknown>
+
+mov {z24.s, z25.s}, za1v.s[w14, 2:3] // 11000000-10000110-11000000-01111000
+// CHECK-INST: mov { z24.s, z25.s }, za1v.s[w14, 2:3]
+// CHECK-ENCODING: [0x78,0xc0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c078 <unknown>
+
+mov {z0.s, z1.s}, za2v.s[w12, 0:1] // 11000000-10000110-10000000-10000000
+// CHECK-INST: mov { z0.s, z1.s }, za2v.s[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868080 <unknown>
+
+mov {z16.s, z17.s}, za0v.s[w14, 2:3] // 11000000-10000110-11000000-00110000
+// CHECK-INST: mov { z16.s, z17.s }, za0v.s[w14, 2:3]
+// CHECK-ENCODING: [0x30,0xc0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c030 <unknown>
+
+mov {z28.s, z29.s}, za3v.s[w12, 0:1] // 11000000-10000110-10000000-11011100
+// CHECK-INST: mov { z28.s, z29.s }, za3v.s[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x80,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08680dc <unknown>
+
+mov {z2.s, z3.s}, za0v.s[w15, 2:3] // 11000000-10000110-11100000-00100010
+// CHECK-INST: mov { z2.s, z3.s }, za0v.s[w15, 2:3]
+// CHECK-ENCODING: [0x22,0xe0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e022 <unknown>
+
+mov {z6.s, z7.s}, za2v.s[w13, 0:1] // 11000000-10000110-10100000-10000110
+// CHECK-INST: mov { z6.s, z7.s }, za2v.s[w13, 0:1]
+// CHECK-ENCODING: [0x86,0xa0,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086a086 <unknown>
+
+
+mova za0h.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-00000000-00000000
+// CHECK-INST: mov za0h.s[w12, 0:1], { z0.s, z1.s }
+// CHECK-ENCODING: [0x00,0x00,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840000 <unknown>
+
+mova za2h.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-01000001-01000101
+// CHECK-INST: mov za2h.s[w14, 2:3], { z10.s, z11.s }
+// CHECK-ENCODING: [0x45,0x41,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844145 <unknown>
+
+mova za3h.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-01100001-10000111
+// CHECK-INST: mov za3h.s[w15, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0x61,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846187 <unknown>
+
+mova za3h.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-01100011-11000111
+// CHECK-INST: mov za3h.s[w15, 2:3], { z30.s, z31.s }
+// CHECK-ENCODING: [0xc7,0x63,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08463c7 <unknown>
+
+mova za2h.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-00000010-00000101
+// CHECK-INST: mov za2h.s[w12, 2:3], { z16.s, z17.s }
+// CHECK-ENCODING: [0x05,0x02,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840205 <unknown>
+
+mova za0h.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-00000000-00000001
+// CHECK-INST: mov za0h.s[w12, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0x00,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840001 <unknown>
+
+mova za0h.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-01000010-01000000
+// CHECK-INST: mov za0h.s[w14, 0:1], { z18.s, z19.s }
+// CHECK-ENCODING: [0x40,0x42,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844240 <unknown>
+
+mova za0h.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-00000001-10000000
+// CHECK-INST: mov za0h.s[w12, 0:1], { z12.s, z13.s }
+// CHECK-ENCODING: [0x80,0x01,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840180 <unknown>
+
+mova za0h.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-01000000-00000001
+// CHECK-INST: mov za0h.s[w14, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0x40,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844001 <unknown>
+
+mova za2h.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-00000010-11000101
+// CHECK-INST: mov za2h.s[w12, 2:3], { z22.s, z23.s }
+// CHECK-ENCODING: [0xc5,0x02,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08402c5 <unknown>
+
+mova za1h.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-01100001-00000010
+// CHECK-INST: mov za1h.s[w15, 0:1], { z8.s, z9.s }
+// CHECK-ENCODING: [0x02,0x61,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846102 <unknown>
+
+mova za3h.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-00100001-10000111
+// CHECK-INST: mov za3h.s[w13, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0x21,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0842187 <unknown>
+
+// Aliases
+
+mov za0h.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-00000000-00000000
+// CHECK-INST: mov za0h.s[w12, 0:1], { z0.s, z1.s }
+// CHECK-ENCODING: [0x00,0x00,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840000 <unknown>
+
+mov za2h.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-01000001-01000101
+// CHECK-INST: mov za2h.s[w14, 2:3], { z10.s, z11.s }
+// CHECK-ENCODING: [0x45,0x41,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844145 <unknown>
+
+mov za3h.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-01100001-10000111
+// CHECK-INST: mov za3h.s[w15, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0x61,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846187 <unknown>
+
+mov za3h.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-01100011-11000111
+// CHECK-INST: mov za3h.s[w15, 2:3], { z30.s, z31.s }
+// CHECK-ENCODING: [0xc7,0x63,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08463c7 <unknown>
+
+mov za2h.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-00000010-00000101
+// CHECK-INST: mov za2h.s[w12, 2:3], { z16.s, z17.s }
+// CHECK-ENCODING: [0x05,0x02,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840205 <unknown>
+
+mov za0h.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-00000000-00000001
+// CHECK-INST: mov za0h.s[w12, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0x00,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840001 <unknown>
+
+mov za0h.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-01000010-01000000
+// CHECK-INST: mov za0h.s[w14, 0:1], { z18.s, z19.s }
+// CHECK-ENCODING: [0x40,0x42,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844240 <unknown>
+
+mov za0h.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-00000001-10000000
+// CHECK-INST: mov za0h.s[w12, 0:1], { z12.s, z13.s }
+// CHECK-ENCODING: [0x80,0x01,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840180 <unknown>
+
+mov za0h.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-01000000-00000001
+// CHECK-INST: mov za0h.s[w14, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0x40,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844001 <unknown>
+
+mov za2h.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-00000010-11000101
+// CHECK-INST: mov za2h.s[w12, 2:3], { z22.s, z23.s }
+// CHECK-ENCODING: [0xc5,0x02,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08402c5 <unknown>
+
+mov za1h.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-01100001-00000010
+// CHECK-INST: mov za1h.s[w15, 0:1], { z8.s, z9.s }
+// CHECK-ENCODING: [0x02,0x61,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846102 <unknown>
+
+mov za3h.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-00100001-10000111
+// CHECK-INST: mov za3h.s[w13, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0x21,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0842187 <unknown>
+
+
+mova za0v.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-10000000-00000000
+// CHECK-INST: mov za0v.s[w12, 0:1], { z0.s, z1.s }
+// CHECK-ENCODING: [0x00,0x80,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848000 <unknown>
+
+mova za2v.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-11000001-01000101
+// CHECK-INST: mov za2v.s[w14, 2:3], { z10.s, z11.s }
+// CHECK-ENCODING: [0x45,0xc1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c145 <unknown>
+
+mova za3v.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-11100001-10000111
+// CHECK-INST: mov za3v.s[w15, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0xe1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e187 <unknown>
+
+mova za3v.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-11100011-11000111
+// CHECK-INST: mov za3v.s[w15, 2:3], { z30.s, z31.s }
+// CHECK-ENCODING: [0xc7,0xe3,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e3c7 <unknown>
+
+mova za2v.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-10000010-00000101
+// CHECK-INST: mov za2v.s[w12, 2:3], { z16.s, z17.s }
+// CHECK-ENCODING: [0x05,0x82,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848205 <unknown>
+
+mova za0v.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-10000000-00000001
+// CHECK-INST: mov za0v.s[w12, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0x80,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848001 <unknown>
+
+mova za0v.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-11000010-01000000
+// CHECK-INST: mov za0v.s[w14, 0:1], { z18.s, z19.s }
+// CHECK-ENCODING: [0x40,0xc2,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c240 <unknown>
+
+mova za0v.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-10000001-10000000
+// CHECK-INST: mov za0v.s[w12, 0:1], { z12.s, z13.s }
+// CHECK-ENCODING: [0x80,0x81,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848180 <unknown>
+
+mova za0v.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-11000000-00000001
+// CHECK-INST: mov za0v.s[w14, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0xc0,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c001 <unknown>
+
+mova za2v.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-10000010-11000101
+// CHECK-INST: mov za2v.s[w12, 2:3], { z22.s, z23.s }
+// CHECK-ENCODING: [0xc5,0x82,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08482c5 <unknown>
+
+mova za1v.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-11100001-00000010
+// CHECK-INST: mov za1v.s[w15, 0:1], { z8.s, z9.s }
+// CHECK-ENCODING: [0x02,0xe1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e102 <unknown>
+
+mova za3v.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-10100001-10000111
+// CHECK-INST: mov za3v.s[w13, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0xa1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084a187 <unknown>
+
+// Aliases
+
+mov za0v.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-10000000-00000000
+// CHECK-INST: mov za0v.s[w12, 0:1], { z0.s, z1.s }
+// CHECK-ENCODING: [0x00,0x80,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848000 <unknown>
+
+mov za2v.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-11000001-01000101
+// CHECK-INST: mov za2v.s[w14, 2:3], { z10.s, z11.s }
+// CHECK-ENCODING: [0x45,0xc1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c145 <unknown>
+
+mov za3v.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-11100001-10000111
+// CHECK-INST: mov za3v.s[w15, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0xe1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e187 <unknown>
+
+mov za3v.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-11100011-11000111
+// CHECK-INST: mov za3v.s[w15, 2:3], { z30.s, z31.s }
+// CHECK-ENCODING: [0xc7,0xe3,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e3c7 <unknown>
+
+mov za2v.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-10000010-00000101
+// CHECK-INST: mov za2v.s[w12, 2:3], { z16.s, z17.s }
+// CHECK-ENCODING: [0x05,0x82,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848205 <unknown>
+
+mov za0v.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-10000000-00000001
+// CHECK-INST: mov za0v.s[w12, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0x80,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848001 <unknown>
+
+mov za0v.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-11000010-01000000
+// CHECK-INST: mov za0v.s[w14, 0:1], { z18.s, z19.s }
+// CHECK-ENCODING: [0x40,0xc2,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c240 <unknown>
+
+mov za0v.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-10000001-10000000
+// CHECK-INST: mov za0v.s[w12, 0:1], { z12.s, z13.s }
+// CHECK-ENCODING: [0x80,0x81,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848180 <unknown>
+
+mov za0v.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-11000000-00000001
+// CHECK-INST: mov za0v.s[w14, 2:3], { z0.s, z1.s }
+// CHECK-ENCODING: [0x01,0xc0,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c001 <unknown>
+
+mov za2v.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-10000010-11000101
+// CHECK-INST: mov za2v.s[w12, 2:3], { z22.s, z23.s }
+// CHECK-ENCODING: [0xc5,0x82,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c08482c5 <unknown>
+
+mov za1v.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-11100001-00000010
+// CHECK-INST: mov za1v.s[w15, 0:1], { z8.s, z9.s }
+// CHECK-ENCODING: [0x02,0xe1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e102 <unknown>
+
+mov za3v.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-10100001-10000111
+// CHECK-INST: mov za3v.s[w13, 2:3], { z12.s, z13.s }
+// CHECK-ENCODING: [0x87,0xa1,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084a187 <unknown>
+
+
+mova {z0.d, z1.d}, za0h.d[w12, 0:1] // 11000000-11000110-00000000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za0h.d[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60000 <unknown>
+
+mova {z20.d, z21.d}, za2h.d[w14, 0:1] // 11000000-11000110-01000000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za2h.d[w14, 0:1]
+// CHECK-ENCODING: [0x54,0x40,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64054 <unknown>
+
+mova {z22.d, z23.d}, za5h.d[w15, 0:1] // 11000000-11000110-01100000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za5h.d[w15, 0:1]
+// CHECK-ENCODING: [0xb6,0x60,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c660b6 <unknown>
+
+mova {z30.d, z31.d}, za7h.d[w15, 0:1] // 11000000-11000110-01100000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za7h.d[w15, 0:1]
+// CHECK-ENCODING: [0xfe,0x60,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c660fe <unknown>
+
+mova {z4.d, z5.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za1h.d[w12, 0:1]
+// CHECK-ENCODING: [0x24,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60024 <unknown>
+
+mova {z0.d, z1.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za1h.d[w12, 0:1]
+// CHECK-ENCODING: [0x20,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60020 <unknown>
+
+mova {z24.d, z25.d}, za3h.d[w14, 0:1] // 11000000-11000110-01000000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za3h.d[w14, 0:1]
+// CHECK-ENCODING: [0x78,0x40,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64078 <unknown>
+
+mova {z0.d, z1.d}, za4h.d[w12, 0:1] // 11000000-11000110-00000000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za4h.d[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60080 <unknown>
+
+mova {z16.d, z17.d}, za1h.d[w14, 0:1] // 11000000-11000110-01000000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za1h.d[w14, 0:1]
+// CHECK-ENCODING: [0x30,0x40,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64030 <unknown>
+
+mova {z28.d, z29.d}, za6h.d[w12, 0:1] // 11000000-11000110-00000000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za6h.d[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c600dc <unknown>
+
+mova {z2.d, z3.d}, za1h.d[w15, 0:1] // 11000000-11000110-01100000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za1h.d[w15, 0:1]
+// CHECK-ENCODING: [0x22,0x60,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c66022 <unknown>
+
+mova {z6.d, z7.d}, za4h.d[w13, 0:1] // 11000000-11000110-00100000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za4h.d[w13, 0:1]
+// CHECK-ENCODING: [0x86,0x20,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c62086 <unknown>
+
+// Aliases
+
+mov {z0.d, z1.d}, za0h.d[w12, 0:1] // 11000000-11000110-00000000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za0h.d[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60000 <unknown>
+
+mov {z20.d, z21.d}, za2h.d[w14, 0:1] // 11000000-11000110-01000000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za2h.d[w14, 0:1]
+// CHECK-ENCODING: [0x54,0x40,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64054 <unknown>
+
+mov {z22.d, z23.d}, za5h.d[w15, 0:1] // 11000000-11000110-01100000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za5h.d[w15, 0:1]
+// CHECK-ENCODING: [0xb6,0x60,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c660b6 <unknown>
+
+mov {z30.d, z31.d}, za7h.d[w15, 0:1] // 11000000-11000110-01100000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za7h.d[w15, 0:1]
+// CHECK-ENCODING: [0xfe,0x60,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c660fe <unknown>
+
+mov {z4.d, z5.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za1h.d[w12, 0:1]
+// CHECK-ENCODING: [0x24,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60024 <unknown>
+
+mov {z0.d, z1.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za1h.d[w12, 0:1]
+// CHECK-ENCODING: [0x20,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60020 <unknown>
+
+mov {z24.d, z25.d}, za3h.d[w14, 0:1] // 11000000-11000110-01000000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za3h.d[w14, 0:1]
+// CHECK-ENCODING: [0x78,0x40,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64078 <unknown>
+
+mov {z0.d, z1.d}, za4h.d[w12, 0:1] // 11000000-11000110-00000000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za4h.d[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60080 <unknown>
+
+mov {z16.d, z17.d}, za1h.d[w14, 0:1] // 11000000-11000110-01000000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za1h.d[w14, 0:1]
+// CHECK-ENCODING: [0x30,0x40,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64030 <unknown>
+
+mov {z28.d, z29.d}, za6h.d[w12, 0:1] // 11000000-11000110-00000000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za6h.d[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x00,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c600dc <unknown>
+
+mov {z2.d, z3.d}, za1h.d[w15, 0:1] // 11000000-11000110-01100000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za1h.d[w15, 0:1]
+// CHECK-ENCODING: [0x22,0x60,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c66022 <unknown>
+
+mov {z6.d, z7.d}, za4h.d[w13, 0:1] // 11000000-11000110-00100000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za4h.d[w13, 0:1]
+// CHECK-ENCODING: [0x86,0x20,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c62086 <unknown>
+
+
+mova {z0.d, z1.d}, za0v.d[w12, 0:1] // 11000000-11000110-10000000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za0v.d[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68000 <unknown>
+
+mova {z20.d, z21.d}, za2v.d[w14, 0:1] // 11000000-11000110-11000000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za2v.d[w14, 0:1]
+// CHECK-ENCODING: [0x54,0xc0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c054 <unknown>
+
+mova {z22.d, z23.d}, za5v.d[w15, 0:1] // 11000000-11000110-11100000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za5v.d[w15, 0:1]
+// CHECK-ENCODING: [0xb6,0xe0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e0b6 <unknown>
+
+mova {z30.d, z31.d}, za7v.d[w15, 0:1] // 11000000-11000110-11100000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za7v.d[w15, 0:1]
+// CHECK-ENCODING: [0xfe,0xe0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e0fe <unknown>
+
+mova {z4.d, z5.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za1v.d[w12, 0:1]
+// CHECK-ENCODING: [0x24,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68024 <unknown>
+
+mova {z0.d, z1.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za1v.d[w12, 0:1]
+// CHECK-ENCODING: [0x20,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68020 <unknown>
+
+mova {z24.d, z25.d}, za3v.d[w14, 0:1] // 11000000-11000110-11000000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za3v.d[w14, 0:1]
+// CHECK-ENCODING: [0x78,0xc0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c078 <unknown>
+
+mova {z0.d, z1.d}, za4v.d[w12, 0:1] // 11000000-11000110-10000000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za4v.d[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68080 <unknown>
+
+mova {z16.d, z17.d}, za1v.d[w14, 0:1] // 11000000-11000110-11000000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za1v.d[w14, 0:1]
+// CHECK-ENCODING: [0x30,0xc0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c030 <unknown>
+
+mova {z28.d, z29.d}, za6v.d[w12, 0:1] // 11000000-11000110-10000000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za6v.d[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c680dc <unknown>
+
+mova {z2.d, z3.d}, za1v.d[w15, 0:1] // 11000000-11000110-11100000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za1v.d[w15, 0:1]
+// CHECK-ENCODING: [0x22,0xe0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e022 <unknown>
+
+mova {z6.d, z7.d}, za4v.d[w13, 0:1] // 11000000-11000110-10100000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za4v.d[w13, 0:1]
+// CHECK-ENCODING: [0x86,0xa0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6a086 <unknown>
+
+// Aliases
+
+mov {z0.d, z1.d}, za0v.d[w12, 0:1] // 11000000-11000110-10000000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za0v.d[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68000 <unknown>
+
+mov {z20.d, z21.d}, za2v.d[w14, 0:1] // 11000000-11000110-11000000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za2v.d[w14, 0:1]
+// CHECK-ENCODING: [0x54,0xc0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c054 <unknown>
+
+mov {z22.d, z23.d}, za5v.d[w15, 0:1] // 11000000-11000110-11100000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za5v.d[w15, 0:1]
+// CHECK-ENCODING: [0xb6,0xe0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e0b6 <unknown>
+
+mov {z30.d, z31.d}, za7v.d[w15, 0:1] // 11000000-11000110-11100000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za7v.d[w15, 0:1]
+// CHECK-ENCODING: [0xfe,0xe0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e0fe <unknown>
+
+mov {z4.d, z5.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za1v.d[w12, 0:1]
+// CHECK-ENCODING: [0x24,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68024 <unknown>
+
+mov {z0.d, z1.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za1v.d[w12, 0:1]
+// CHECK-ENCODING: [0x20,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68020 <unknown>
+
+mov {z24.d, z25.d}, za3v.d[w14, 0:1] // 11000000-11000110-11000000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za3v.d[w14, 0:1]
+// CHECK-ENCODING: [0x78,0xc0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c078 <unknown>
+
+mov {z0.d, z1.d}, za4v.d[w12, 0:1] // 11000000-11000110-10000000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za4v.d[w12, 0:1]
+// CHECK-ENCODING: [0x80,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68080 <unknown>
+
+mov {z16.d, z17.d}, za1v.d[w14, 0:1] // 11000000-11000110-11000000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za1v.d[w14, 0:1]
+// CHECK-ENCODING: [0x30,0xc0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c030 <unknown>
+
+mov {z28.d, z29.d}, za6v.d[w12, 0:1] // 11000000-11000110-10000000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za6v.d[w12, 0:1]
+// CHECK-ENCODING: [0xdc,0x80,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c680dc <unknown>
+
+mov {z2.d, z3.d}, za1v.d[w15, 0:1] // 11000000-11000110-11100000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za1v.d[w15, 0:1]
+// CHECK-ENCODING: [0x22,0xe0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e022 <unknown>
+
+mov {z6.d, z7.d}, za4v.d[w13, 0:1] // 11000000-11000110-10100000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za4v.d[w13, 0:1]
+// CHECK-ENCODING: [0x86,0xa0,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6a086 <unknown>
+
+
+mova {z0.d, z1.d}, za.d[w8, 0, vgx2] // 11000000-00000110-00001000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 0, vgx2]
+// CHECK-ENCODING: [0x00,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060800 <unknown>
+
+mova {z0.d, z1.d}, za.d[w8, 0] // 11000000-00000110-00001000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 0, vgx2]
+// CHECK-ENCODING: [0x00,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060800 <unknown>
+
+mova {z20.d, z21.d}, za.d[w10, 2, vgx2] // 11000000-00000110-01001000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za.d[w10, 2, vgx2]
+// CHECK-ENCODING: [0x54,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064854 <unknown>
+
+mova {z20.d, z21.d}, za.d[w10, 2] // 11000000-00000110-01001000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za.d[w10, 2, vgx2]
+// CHECK-ENCODING: [0x54,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064854 <unknown>
+
+mova {z22.d, z23.d}, za.d[w11, 5, vgx2] // 11000000-00000110-01101000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za.d[w11, 5, vgx2]
+// CHECK-ENCODING: [0xb6,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00668b6 <unknown>
+
+mova {z22.d, z23.d}, za.d[w11, 5] // 11000000-00000110-01101000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za.d[w11, 5, vgx2]
+// CHECK-ENCODING: [0xb6,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00668b6 <unknown>
+
+mova {z30.d, z31.d}, za.d[w11, 7, vgx2] // 11000000-00000110-01101000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za.d[w11, 7, vgx2]
+// CHECK-ENCODING: [0xfe,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00668fe <unknown>
+
+mova {z30.d, z31.d}, za.d[w11, 7] // 11000000-00000110-01101000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za.d[w11, 7, vgx2]
+// CHECK-ENCODING: [0xfe,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00668fe <unknown>
+
+mova {z4.d, z5.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za.d[w8, 1, vgx2]
+// CHECK-ENCODING: [0x24,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060824 <unknown>
+
+mova {z4.d, z5.d}, za.d[w8, 1] // 11000000-00000110-00001000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za.d[w8, 1, vgx2]
+// CHECK-ENCODING: [0x24,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060824 <unknown>
+
+mova {z0.d, z1.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 1, vgx2]
+// CHECK-ENCODING: [0x20,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060820 <unknown>
+
+mova {z0.d, z1.d}, za.d[w8, 1] // 11000000-00000110-00001000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 1, vgx2]
+// CHECK-ENCODING: [0x20,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060820 <unknown>
+
+mova {z24.d, z25.d}, za.d[w10, 3, vgx2] // 11000000-00000110-01001000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za.d[w10, 3, vgx2]
+// CHECK-ENCODING: [0x78,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064878 <unknown>
+
+mova {z24.d, z25.d}, za.d[w10, 3] // 11000000-00000110-01001000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za.d[w10, 3, vgx2]
+// CHECK-ENCODING: [0x78,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064878 <unknown>
+
+mova {z0.d, z1.d}, za.d[w8, 4, vgx2] // 11000000-00000110-00001000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 4, vgx2]
+// CHECK-ENCODING: [0x80,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060880 <unknown>
+
+mova {z0.d, z1.d}, za.d[w8, 4] // 11000000-00000110-00001000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 4, vgx2]
+// CHECK-ENCODING: [0x80,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060880 <unknown>
+
+mova {z16.d, z17.d}, za.d[w10, 1, vgx2] // 11000000-00000110-01001000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za.d[w10, 1, vgx2]
+// CHECK-ENCODING: [0x30,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064830 <unknown>
+
+mova {z16.d, z17.d}, za.d[w10, 1] // 11000000-00000110-01001000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za.d[w10, 1, vgx2]
+// CHECK-ENCODING: [0x30,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064830 <unknown>
+
+mova {z28.d, z29.d}, za.d[w8, 6, vgx2] // 11000000-00000110-00001000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za.d[w8, 6, vgx2]
+// CHECK-ENCODING: [0xdc,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00608dc <unknown>
+
+mova {z28.d, z29.d}, za.d[w8, 6] // 11000000-00000110-00001000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za.d[w8, 6, vgx2]
+// CHECK-ENCODING: [0xdc,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00608dc <unknown>
+
+mova {z2.d, z3.d}, za.d[w11, 1, vgx2] // 11000000-00000110-01101000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za.d[w11, 1, vgx2]
+// CHECK-ENCODING: [0x22,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066822 <unknown>
+
+mova {z2.d, z3.d}, za.d[w11, 1] // 11000000-00000110-01101000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za.d[w11, 1, vgx2]
+// CHECK-ENCODING: [0x22,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066822 <unknown>
+
+mova {z6.d, z7.d}, za.d[w9, 4, vgx2] // 11000000-00000110-00101000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za.d[w9, 4, vgx2]
+// CHECK-ENCODING: [0x86,0x28,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062886 <unknown>
+
+mova {z6.d, z7.d}, za.d[w9, 4] // 11000000-00000110-00101000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za.d[w9, 4, vgx2]
+// CHECK-ENCODING: [0x86,0x28,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062886 <unknown>
+
+// Aliases
+
+mov {z0.d, z1.d}, za.d[w8, 0, vgx2] // 11000000-00000110-00001000-00000000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 0, vgx2]
+// CHECK-ENCODING: [0x00,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060800 <unknown>
+
+mov {z20.d, z21.d}, za.d[w10, 2, vgx2] // 11000000-00000110-01001000-01010100
+// CHECK-INST: mov { z20.d, z21.d }, za.d[w10, 2, vgx2]
+// CHECK-ENCODING: [0x54,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064854 <unknown>
+
+mov {z22.d, z23.d}, za.d[w11, 5, vgx2] // 11000000-00000110-01101000-10110110
+// CHECK-INST: mov { z22.d, z23.d }, za.d[w11, 5, vgx2]
+// CHECK-ENCODING: [0xb6,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00668b6 <unknown>
+
+mov {z30.d, z31.d}, za.d[w11, 7, vgx2] // 11000000-00000110-01101000-11111110
+// CHECK-INST: mov { z30.d, z31.d }, za.d[w11, 7, vgx2]
+// CHECK-ENCODING: [0xfe,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00668fe <unknown>
+
+mov {z4.d, z5.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100100
+// CHECK-INST: mov { z4.d, z5.d }, za.d[w8, 1, vgx2]
+// CHECK-ENCODING: [0x24,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060824 <unknown>
+
+mov {z0.d, z1.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 1, vgx2]
+// CHECK-ENCODING: [0x20,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060820 <unknown>
+
+mov {z24.d, z25.d}, za.d[w10, 3, vgx2] // 11000000-00000110-01001000-01111000
+// CHECK-INST: mov { z24.d, z25.d }, za.d[w10, 3, vgx2]
+// CHECK-ENCODING: [0x78,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064878 <unknown>
+
+mov {z0.d, z1.d}, za.d[w8, 4, vgx2] // 11000000-00000110-00001000-10000000
+// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 4, vgx2]
+// CHECK-ENCODING: [0x80,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060880 <unknown>
+
+mov {z16.d, z17.d}, za.d[w10, 1, vgx2] // 11000000-00000110-01001000-00110000
+// CHECK-INST: mov { z16.d, z17.d }, za.d[w10, 1, vgx2]
+// CHECK-ENCODING: [0x30,0x48,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064830 <unknown>
+
+mov {z28.d, z29.d}, za.d[w8, 6, vgx2] // 11000000-00000110-00001000-11011100
+// CHECK-INST: mov { z28.d, z29.d }, za.d[w8, 6, vgx2]
+// CHECK-ENCODING: [0xdc,0x08,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00608dc <unknown>
+
+mov {z2.d, z3.d}, za.d[w11, 1, vgx2] // 11000000-00000110-01101000-00100010
+// CHECK-INST: mov { z2.d, z3.d }, za.d[w11, 1, vgx2]
+// CHECK-ENCODING: [0x22,0x68,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066822 <unknown>
+
+mov {z6.d, z7.d}, za.d[w9, 4, vgx2] // 11000000-00000110-00101000-10000110
+// CHECK-INST: mov { z6.d, z7.d }, za.d[w9, 4, vgx2]
+// CHECK-ENCODING: [0x86,0x28,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062886 <unknown>
+
+
+mova za0h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000000
+// CHECK-INST: mov za0h.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x00,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40000 <unknown>
+
+mova za5h.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-01000001-01000101
+// CHECK-INST: mov za5h.d[w14, 0:1], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0x41,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44145 <unknown>
+
+mova za7h.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-01100001-10000111
+// CHECK-INST: mov za7h.d[w15, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x61,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46187 <unknown>
+
+mova za7h.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-01100011-11000111
+// CHECK-INST: mov za7h.d[w15, 0:1], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0x63,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c463c7 <unknown>
+
+mova za5h.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-00000010-00000101
+// CHECK-INST: mov za5h.d[w12, 0:1], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x02,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40205 <unknown>
+
+mova za1h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000001
+// CHECK-INST: mov za1h.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x00,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40001 <unknown>
+
+mova za0h.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-01000010-01000000
+// CHECK-INST: mov za0h.d[w14, 0:1], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0x42,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44240 <unknown>
+
+mova za0h.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-00000001-10000000
+// CHECK-INST: mov za0h.d[w12, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x01,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40180 <unknown>
+
+mova za1h.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-01000000-00000001
+// CHECK-INST: mov za1h.d[w14, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x40,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44001 <unknown>
+
+mova za5h.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-00000010-11000101
+// CHECK-INST: mov za5h.d[w12, 0:1], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x02,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c402c5 <unknown>
+
+mova za2h.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-01100001-00000010
+// CHECK-INST: mov za2h.d[w15, 0:1], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0x61,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46102 <unknown>
+
+mova za7h.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-00100001-10000111
+// CHECK-INST: mov za7h.d[w13, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x21,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c42187 <unknown>
+
+// Aliases
+
+mov za0h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000000
+// CHECK-INST: mov za0h.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x00,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40000 <unknown>
+
+mov za5h.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-01000001-01000101
+// CHECK-INST: mov za5h.d[w14, 0:1], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0x41,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44145 <unknown>
+
+mov za7h.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-01100001-10000111
+// CHECK-INST: mov za7h.d[w15, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x61,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46187 <unknown>
+
+mov za7h.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-01100011-11000111
+// CHECK-INST: mov za7h.d[w15, 0:1], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0x63,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c463c7 <unknown>
+
+mov za5h.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-00000010-00000101
+// CHECK-INST: mov za5h.d[w12, 0:1], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x02,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40205 <unknown>
+
+mov za1h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000001
+// CHECK-INST: mov za1h.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x00,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40001 <unknown>
+
+mov za0h.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-01000010-01000000
+// CHECK-INST: mov za0h.d[w14, 0:1], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0x42,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44240 <unknown>
+
+mov za0h.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-00000001-10000000
+// CHECK-INST: mov za0h.d[w12, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x01,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40180 <unknown>
+
+mov za1h.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-01000000-00000001
+// CHECK-INST: mov za1h.d[w14, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x40,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44001 <unknown>
+
+mov za5h.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-00000010-11000101
+// CHECK-INST: mov za5h.d[w12, 0:1], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x02,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c402c5 <unknown>
+
+mov za2h.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-01100001-00000010
+// CHECK-INST: mov za2h.d[w15, 0:1], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0x61,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46102 <unknown>
+
+mov za7h.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-00100001-10000111
+// CHECK-INST: mov za7h.d[w13, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x21,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c42187 <unknown>
+
+
+mova za0v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000000
+// CHECK-INST: mov za0v.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x80,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48000 <unknown>
+
+mova za5v.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-11000001-01000101
+// CHECK-INST: mov za5v.d[w14, 0:1], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0xc1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c145 <unknown>
+
+mova za7v.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-11100001-10000111
+// CHECK-INST: mov za7v.d[w15, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0xe1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e187 <unknown>
+
+mova za7v.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-11100011-11000111
+// CHECK-INST: mov za7v.d[w15, 0:1], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0xe3,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e3c7 <unknown>
+
+mova za5v.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-10000010-00000101
+// CHECK-INST: mov za5v.d[w12, 0:1], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x82,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48205 <unknown>
+
+mova za1v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000001
+// CHECK-INST: mov za1v.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x80,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48001 <unknown>
+
+mova za0v.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-11000010-01000000
+// CHECK-INST: mov za0v.d[w14, 0:1], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0xc2,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c240 <unknown>
+
+mova za0v.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-10000001-10000000
+// CHECK-INST: mov za0v.d[w12, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x81,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48180 <unknown>
+
+mova za1v.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-11000000-00000001
+// CHECK-INST: mov za1v.d[w14, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0xc0,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c001 <unknown>
+
+mova za5v.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-10000010-11000101
+// CHECK-INST: mov za5v.d[w12, 0:1], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x82,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c482c5 <unknown>
+
+mova za2v.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-11100001-00000010
+// CHECK-INST: mov za2v.d[w15, 0:1], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0xe1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e102 <unknown>
+
+mova za7v.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-10100001-10000111
+// CHECK-INST: mov za7v.d[w13, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0xa1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4a187 <unknown>
+
+// Aliases
+
+mov za0v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000000
+// CHECK-INST: mov za0v.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x80,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48000 <unknown>
+
+mov za5v.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-11000001-01000101
+// CHECK-INST: mov za5v.d[w14, 0:1], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0xc1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c145 <unknown>
+
+mov za7v.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-11100001-10000111
+// CHECK-INST: mov za7v.d[w15, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0xe1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e187 <unknown>
+
+mov za7v.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-11100011-11000111
+// CHECK-INST: mov za7v.d[w15, 0:1], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0xe3,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e3c7 <unknown>
+
+mov za5v.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-10000010-00000101
+// CHECK-INST: mov za5v.d[w12, 0:1], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x82,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48205 <unknown>
+
+mov za1v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000001
+// CHECK-INST: mov za1v.d[w12, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x80,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48001 <unknown>
+
+mov za0v.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-11000010-01000000
+// CHECK-INST: mov za0v.d[w14, 0:1], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0xc2,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c240 <unknown>
+
+mov za0v.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-10000001-10000000
+// CHECK-INST: mov za0v.d[w12, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x81,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48180 <unknown>
+
+mov za1v.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-11000000-00000001
+// CHECK-INST: mov za1v.d[w14, 0:1], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0xc0,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c001 <unknown>
+
+mov za5v.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-10000010-11000101
+// CHECK-INST: mov za5v.d[w12, 0:1], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x82,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c482c5 <unknown>
+
+mov za2v.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-11100001-00000010
+// CHECK-INST: mov za2v.d[w15, 0:1], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0xe1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e102 <unknown>
+
+mov za7v.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-10100001-10000111
+// CHECK-INST: mov za7v.d[w13, 0:1], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0xa1,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4a187 <unknown>
+
+
+mova za.d[w8, 0, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000000
+// CHECK-INST: mov za.d[w8, 0, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x08,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040800 <unknown>
+
+mova za.d[w8, 0], {z0.d, z1.d} // 11000000-00000100-00001000-00000000
+// CHECK-INST: mov za.d[w8, 0, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x08,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040800 <unknown>
+
+mova za.d[w10, 5, vgx2], {z10.d, z11.d} // 11000000-00000100-01001001-01000101
+// CHECK-INST: mov za.d[w10, 5, vgx2], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0x49,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044945 <unknown>
+
+mova za.d[w10, 5], {z10.d, z11.d} // 11000000-00000100-01001001-01000101
+// CHECK-INST: mov za.d[w10, 5, vgx2], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0x49,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044945 <unknown>
+
+mova za.d[w11, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-01101001-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x69,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046987 <unknown>
+
+mova za.d[w11, 7], {z12.d, z13.d} // 11000000-00000100-01101001-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x69,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046987 <unknown>
+
+mova za.d[w11, 7, vgx2], {z30.d, z31.d} // 11000000-00000100-01101011-11000111
+// CHECK-INST: mov za.d[w11, 7, vgx2], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0x6b,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046bc7 <unknown>
+
+mova za.d[w11, 7], {z30.d, z31.d} // 11000000-00000100-01101011-11000111
+// CHECK-INST: mov za.d[w11, 7, vgx2], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0x6b,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046bc7 <unknown>
+
+mova za.d[w8, 5, vgx2], {z16.d, z17.d} // 11000000-00000100-00001010-00000101
+// CHECK-INST: mov za.d[w8, 5, vgx2], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x0a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040a05 <unknown>
+
+mova za.d[w8, 5], {z16.d, z17.d} // 11000000-00000100-00001010-00000101
+// CHECK-INST: mov za.d[w8, 5, vgx2], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x0a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040a05 <unknown>
+
+mova za.d[w8, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000001
+// CHECK-INST: mov za.d[w8, 1, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x08,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040801 <unknown>
+
+mova za.d[w8, 1], {z0.d, z1.d} // 11000000-00000100-00001000-00000001
+// CHECK-INST: mov za.d[w8, 1, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x08,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040801 <unknown>
+
+mova za.d[w10, 0, vgx2], {z18.d, z19.d} // 11000000-00000100-01001010-01000000
+// CHECK-INST: mov za.d[w10, 0, vgx2], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0x4a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044a40 <unknown>
+
+mova za.d[w10, 0], {z18.d, z19.d} // 11000000-00000100-01001010-01000000
+// CHECK-INST: mov za.d[w10, 0, vgx2], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0x4a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044a40 <unknown>
+
+mova za.d[w8, 0, vgx2], {z12.d, z13.d} // 11000000-00000100-00001001-10000000
+// CHECK-INST: mov za.d[w8, 0, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x09,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040980 <unknown>
+
+mova za.d[w8, 0], {z12.d, z13.d} // 11000000-00000100-00001001-10000000
+// CHECK-INST: mov za.d[w8, 0, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x09,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040980 <unknown>
+
+mova za.d[w10, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-01001000-00000001
+// CHECK-INST: mov za.d[w10, 1, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x48,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044801 <unknown>
+
+mova za.d[w10, 1], {z0.d, z1.d} // 11000000-00000100-01001000-00000001
+// CHECK-INST: mov za.d[w10, 1, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x48,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044801 <unknown>
+
+mova za.d[w8, 5, vgx2], {z22.d, z23.d} // 11000000-00000100-00001010-11000101
+// CHECK-INST: mov za.d[w8, 5, vgx2], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x0a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040ac5 <unknown>
+
+mova za.d[w8, 5], {z22.d, z23.d} // 11000000-00000100-00001010-11000101
+// CHECK-INST: mov za.d[w8, 5, vgx2], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x0a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040ac5 <unknown>
+
+mova za.d[w11, 2, vgx2], {z8.d, z9.d} // 11000000-00000100-01101001-00000010
+// CHECK-INST: mov za.d[w11, 2, vgx2], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0x69,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046902 <unknown>
+
+mova za.d[w11, 2], {z8.d, z9.d} // 11000000-00000100-01101001-00000010
+// CHECK-INST: mov za.d[w11, 2, vgx2], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0x69,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046902 <unknown>
+
+mova za.d[w9, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-00101001-10000111
+// CHECK-INST: mov za.d[w9, 7, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x29,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042987 <unknown>
+
+mova za.d[w9, 7], {z12.d, z13.d} // 11000000-00000100-00101001-10000111
+// CHECK-INST: mov za.d[w9, 7, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x29,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042987 <unknown>
+
+// Aliases
+
+mov za.d[w8, 0, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000000
+// CHECK-INST: mov za.d[w8, 0, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x00,0x08,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040800 <unknown>
+
+mov za.d[w10, 5, vgx2], {z10.d, z11.d} // 11000000-00000100-01001001-01000101
+// CHECK-INST: mov za.d[w10, 5, vgx2], { z10.d, z11.d }
+// CHECK-ENCODING: [0x45,0x49,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044945 <unknown>
+
+mov za.d[w11, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-01101001-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x69,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046987 <unknown>
+
+mov za.d[w11, 7, vgx2], {z30.d, z31.d} // 11000000-00000100-01101011-11000111
+// CHECK-INST: mov za.d[w11, 7, vgx2], { z30.d, z31.d }
+// CHECK-ENCODING: [0xc7,0x6b,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046bc7 <unknown>
+
+mov za.d[w8, 5, vgx2], {z16.d, z17.d} // 11000000-00000100-00001010-00000101
+// CHECK-INST: mov za.d[w8, 5, vgx2], { z16.d, z17.d }
+// CHECK-ENCODING: [0x05,0x0a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040a05 <unknown>
+
+mov za.d[w8, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000001
+// CHECK-INST: mov za.d[w8, 1, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x08,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040801 <unknown>
+
+mov za.d[w10, 0, vgx2], {z18.d, z19.d} // 11000000-00000100-01001010-01000000
+// CHECK-INST: mov za.d[w10, 0, vgx2], { z18.d, z19.d }
+// CHECK-ENCODING: [0x40,0x4a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044a40 <unknown>
+
+mov za.d[w8, 0, vgx2], {z12.d, z13.d} // 11000000-00000100-00001001-10000000
+// CHECK-INST: mov za.d[w8, 0, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x80,0x09,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040980 <unknown>
+
+mov za.d[w10, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-01001000-00000001
+// CHECK-INST: mov za.d[w10, 1, vgx2], { z0.d, z1.d }
+// CHECK-ENCODING: [0x01,0x48,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044801 <unknown>
+
+mov za.d[w8, 5, vgx2], {z22.d, z23.d} // 11000000-00000100-00001010-11000101
+// CHECK-INST: mov za.d[w8, 5, vgx2], { z22.d, z23.d }
+// CHECK-ENCODING: [0xc5,0x0a,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040ac5 <unknown>
+
+mov za.d[w11, 2, vgx2], {z8.d, z9.d} // 11000000-00000100-01101001-00000010
+// CHECK-INST: mov za.d[w11, 2, vgx2], { z8.d, z9.d }
+// CHECK-ENCODING: [0x02,0x69,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046902 <unknown>
+
+mov za.d[w9, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-00101001-10000111
+// CHECK-INST: mov za.d[w9, 7, vgx2], { z12.d, z13.d }
+// CHECK-ENCODING: [0x87,0x29,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042987 <unknown>
+
+
+mova {z0.b, z1.b}, za0h.b[w12, 0:1] // 11000000-00000110-00000000-00000000
+// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060000 <unknown>
+
+mova {z20.b, z21.b}, za0h.b[w14, 4:5] // 11000000-00000110-01000000-01010100
+// CHECK-INST: mov { z20.b, z21.b }, za0h.b[w14, 4:5]
+// CHECK-ENCODING: [0x54,0x40,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064054 <unknown>
+
+mova {z22.b, z23.b}, za0h.b[w15, 10:11] // 11000000-00000110-01100000-10110110
+// CHECK-INST: mov { z22.b, z23.b }, za0h.b[w15, 10:11]
+// CHECK-ENCODING: [0xb6,0x60,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00660b6 <unknown>
+
+mova {z30.b, z31.b}, za0h.b[w15, 14:15] // 11000000-00000110-01100000-11111110
+// CHECK-INST: mov { z30.b, z31.b }, za0h.b[w15, 14:15]
+// CHECK-ENCODING: [0xfe,0x60,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00660fe <unknown>
+
+mova {z4.b, z5.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100100
+// CHECK-INST: mov { z4.b, z5.b }, za0h.b[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060024 <unknown>
+
+mova {z0.b, z1.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100000
+// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060020 <unknown>
+
+mova {z24.b, z25.b}, za0h.b[w14, 6:7] // 11000000-00000110-01000000-01111000
+// CHECK-INST: mov { z24.b, z25.b }, za0h.b[w14, 6:7]
+// CHECK-ENCODING: [0x78,0x40,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064078 <unknown>
+
+mova {z0.b, z1.b}, za0h.b[w12, 8:9] // 11000000-00000110-00000000-10000000
+// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 8:9]
+// CHECK-ENCODING: [0x80,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060080 <unknown>
+
+mova {z16.b, z17.b}, za0h.b[w14, 2:3] // 11000000-00000110-01000000-00110000
+// CHECK-INST: mov { z16.b, z17.b }, za0h.b[w14, 2:3]
+// CHECK-ENCODING: [0x30,0x40,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064030 <unknown>
+
+mova {z28.b, z29.b}, za0h.b[w12, 12:13] // 11000000-00000110-00000000-11011100
+// CHECK-INST: mov { z28.b, z29.b }, za0h.b[w12, 12:13]
+// CHECK-ENCODING: [0xdc,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00600dc <unknown>
+
+mova {z2.b, z3.b}, za0h.b[w15, 2:3] // 11000000-00000110-01100000-00100010
+// CHECK-INST: mov { z2.b, z3.b }, za0h.b[w15, 2:3]
+// CHECK-ENCODING: [0x22,0x60,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066022 <unknown>
+
+mova {z6.b, z7.b}, za0h.b[w13, 8:9] // 11000000-00000110-00100000-10000110
+// CHECK-INST: mov { z6.b, z7.b }, za0h.b[w13, 8:9]
+// CHECK-ENCODING: [0x86,0x20,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062086 <unknown>
+
+// Aliases
+
+mov {z0.b, z1.b}, za0h.b[w12, 0:1] // 11000000-00000110-00000000-00000000
+// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060000 <unknown>
+
+mov {z20.b, z21.b}, za0h.b[w14, 4:5] // 11000000-00000110-01000000-01010100
+// CHECK-INST: mov { z20.b, z21.b }, za0h.b[w14, 4:5]
+// CHECK-ENCODING: [0x54,0x40,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064054 <unknown>
+
+mov {z22.b, z23.b}, za0h.b[w15, 10:11] // 11000000-00000110-01100000-10110110
+// CHECK-INST: mov { z22.b, z23.b }, za0h.b[w15, 10:11]
+// CHECK-ENCODING: [0xb6,0x60,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00660b6 <unknown>
+
+mov {z30.b, z31.b}, za0h.b[w15, 14:15] // 11000000-00000110-01100000-11111110
+// CHECK-INST: mov { z30.b, z31.b }, za0h.b[w15, 14:15]
+// CHECK-ENCODING: [0xfe,0x60,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00660fe <unknown>
+
+mov {z4.b, z5.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100100
+// CHECK-INST: mov { z4.b, z5.b }, za0h.b[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060024 <unknown>
+
+mov {z0.b, z1.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100000
+// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060020 <unknown>
+
+mov {z24.b, z25.b}, za0h.b[w14, 6:7] // 11000000-00000110-01000000-01111000
+// CHECK-INST: mov { z24.b, z25.b }, za0h.b[w14, 6:7]
+// CHECK-ENCODING: [0x78,0x40,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064078 <unknown>
+
+mov {z0.b, z1.b}, za0h.b[w12, 8:9] // 11000000-00000110-00000000-10000000
+// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 8:9]
+// CHECK-ENCODING: [0x80,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060080 <unknown>
+
+mov {z16.b, z17.b}, za0h.b[w14, 2:3] // 11000000-00000110-01000000-00110000
+// CHECK-INST: mov { z16.b, z17.b }, za0h.b[w14, 2:3]
+// CHECK-ENCODING: [0x30,0x40,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064030 <unknown>
+
+mov {z28.b, z29.b}, za0h.b[w12, 12:13] // 11000000-00000110-00000000-11011100
+// CHECK-INST: mov { z28.b, z29.b }, za0h.b[w12, 12:13]
+// CHECK-ENCODING: [0xdc,0x00,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00600dc <unknown>
+
+mov {z2.b, z3.b}, za0h.b[w15, 2:3] // 11000000-00000110-01100000-00100010
+// CHECK-INST: mov { z2.b, z3.b }, za0h.b[w15, 2:3]
+// CHECK-ENCODING: [0x22,0x60,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066022 <unknown>
+
+mov {z6.b, z7.b}, za0h.b[w13, 8:9] // 11000000-00000110-00100000-10000110
+// CHECK-INST: mov { z6.b, z7.b }, za0h.b[w13, 8:9]
+// CHECK-ENCODING: [0x86,0x20,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062086 <unknown>
+
+
+mova {z0.b, z1.b}, za0v.b[w12, 0:1] // 11000000-00000110-10000000-00000000
+// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068000 <unknown>
+
+mova {z20.b, z21.b}, za0v.b[w14, 4:5] // 11000000-00000110-11000000-01010100
+// CHECK-INST: mov { z20.b, z21.b }, za0v.b[w14, 4:5]
+// CHECK-ENCODING: [0x54,0xc0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c054 <unknown>
+
+mova {z22.b, z23.b}, za0v.b[w15, 10:11] // 11000000-00000110-11100000-10110110
+// CHECK-INST: mov { z22.b, z23.b }, za0v.b[w15, 10:11]
+// CHECK-ENCODING: [0xb6,0xe0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e0b6 <unknown>
+
+mova {z30.b, z31.b}, za0v.b[w15, 14:15] // 11000000-00000110-11100000-11111110
+// CHECK-INST: mov { z30.b, z31.b }, za0v.b[w15, 14:15]
+// CHECK-ENCODING: [0xfe,0xe0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e0fe <unknown>
+
+mova {z4.b, z5.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100100
+// CHECK-INST: mov { z4.b, z5.b }, za0v.b[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068024 <unknown>
+
+mova {z0.b, z1.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100000
+// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068020 <unknown>
+
+mova {z24.b, z25.b}, za0v.b[w14, 6:7] // 11000000-00000110-11000000-01111000
+// CHECK-INST: mov { z24.b, z25.b }, za0v.b[w14, 6:7]
+// CHECK-ENCODING: [0x78,0xc0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c078 <unknown>
+
+mova {z0.b, z1.b}, za0v.b[w12, 8:9] // 11000000-00000110-10000000-10000000
+// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 8:9]
+// CHECK-ENCODING: [0x80,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068080 <unknown>
+
+mova {z16.b, z17.b}, za0v.b[w14, 2:3] // 11000000-00000110-11000000-00110000
+// CHECK-INST: mov { z16.b, z17.b }, za0v.b[w14, 2:3]
+// CHECK-ENCODING: [0x30,0xc0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c030 <unknown>
+
+mova {z28.b, z29.b}, za0v.b[w12, 12:13] // 11000000-00000110-10000000-11011100
+// CHECK-INST: mov { z28.b, z29.b }, za0v.b[w12, 12:13]
+// CHECK-ENCODING: [0xdc,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00680dc <unknown>
+
+mova {z2.b, z3.b}, za0v.b[w15, 2:3] // 11000000-00000110-11100000-00100010
+// CHECK-INST: mov { z2.b, z3.b }, za0v.b[w15, 2:3]
+// CHECK-ENCODING: [0x22,0xe0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e022 <unknown>
+
+mova {z6.b, z7.b}, za0v.b[w13, 8:9] // 11000000-00000110-10100000-10000110
+// CHECK-INST: mov { z6.b, z7.b }, za0v.b[w13, 8:9]
+// CHECK-ENCODING: [0x86,0xa0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006a086 <unknown>
+
+// Aliases
+
+mov {z0.b, z1.b}, za0v.b[w12, 0:1] // 11000000-00000110-10000000-00000000
+// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 0:1]
+// CHECK-ENCODING: [0x00,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068000 <unknown>
+
+mov {z20.b, z21.b}, za0v.b[w14, 4:5] // 11000000-00000110-11000000-01010100
+// CHECK-INST: mov { z20.b, z21.b }, za0v.b[w14, 4:5]
+// CHECK-ENCODING: [0x54,0xc0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c054 <unknown>
+
+mov {z22.b, z23.b}, za0v.b[w15, 10:11] // 11000000-00000110-11100000-10110110
+// CHECK-INST: mov { z22.b, z23.b }, za0v.b[w15, 10:11]
+// CHECK-ENCODING: [0xb6,0xe0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e0b6 <unknown>
+
+mov {z30.b, z31.b}, za0v.b[w15, 14:15] // 11000000-00000110-11100000-11111110
+// CHECK-INST: mov { z30.b, z31.b }, za0v.b[w15, 14:15]
+// CHECK-ENCODING: [0xfe,0xe0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e0fe <unknown>
+
+mov {z4.b, z5.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100100
+// CHECK-INST: mov { z4.b, z5.b }, za0v.b[w12, 2:3]
+// CHECK-ENCODING: [0x24,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068024 <unknown>
+
+mov {z0.b, z1.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100000
+// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 2:3]
+// CHECK-ENCODING: [0x20,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068020 <unknown>
+
+mov {z24.b, z25.b}, za0v.b[w14, 6:7] // 11000000-00000110-11000000-01111000
+// CHECK-INST: mov { z24.b, z25.b }, za0v.b[w14, 6:7]
+// CHECK-ENCODING: [0x78,0xc0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c078 <unknown>
+
+mov {z0.b, z1.b}, za0v.b[w12, 8:9] // 11000000-00000110-10000000-10000000
+// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 8:9]
+// CHECK-ENCODING: [0x80,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068080 <unknown>
+
+mov {z16.b, z17.b}, za0v.b[w14, 2:3] // 11000000-00000110-11000000-00110000
+// CHECK-INST: mov { z16.b, z17.b }, za0v.b[w14, 2:3]
+// CHECK-ENCODING: [0x30,0xc0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c030 <unknown>
+
+mov {z28.b, z29.b}, za0v.b[w12, 12:13] // 11000000-00000110-10000000-11011100
+// CHECK-INST: mov { z28.b, z29.b }, za0v.b[w12, 12:13]
+// CHECK-ENCODING: [0xdc,0x80,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00680dc <unknown>
+
+mov {z2.b, z3.b}, za0v.b[w15, 2:3] // 11000000-00000110-11100000-00100010
+// CHECK-INST: mov { z2.b, z3.b }, za0v.b[w15, 2:3]
+// CHECK-ENCODING: [0x22,0xe0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e022 <unknown>
+
+mov {z6.b, z7.b}, za0v.b[w13, 8:9] // 11000000-00000110-10100000-10000110
+// CHECK-INST: mov { z6.b, z7.b }, za0v.b[w13, 8:9]
+// CHECK-ENCODING: [0x86,0xa0,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006a086 <unknown>
+
+
+mova za0h.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-00000000-00000000
+// CHECK-INST: mov za0h.b[w12, 0:1], { z0.b, z1.b }
+// CHECK-ENCODING: [0x00,0x00,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040000 <unknown>
+
+mova za0h.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-01000001-01000101
+// CHECK-INST: mov za0h.b[w14, 10:11], { z10.b, z11.b }
+// CHECK-ENCODING: [0x45,0x41,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044145 <unknown>
+
+mova za0h.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-01100001-10000111
+// CHECK-INST: mov za0h.b[w15, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0x61,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046187 <unknown>
+
+mova za0h.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-01100011-11000111
+// CHECK-INST: mov za0h.b[w15, 14:15], { z30.b, z31.b }
+// CHECK-ENCODING: [0xc7,0x63,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00463c7 <unknown>
+
+mova za0h.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-00000010-00000101
+// CHECK-INST: mov za0h.b[w12, 10:11], { z16.b, z17.b }
+// CHECK-ENCODING: [0x05,0x02,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040205 <unknown>
+
+mova za0h.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-00000000-00000001
+// CHECK-INST: mov za0h.b[w12, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0x00,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040001 <unknown>
+
+mova za0h.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-01000010-01000000
+// CHECK-INST: mov za0h.b[w14, 0:1], { z18.b, z19.b }
+// CHECK-ENCODING: [0x40,0x42,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044240 <unknown>
+
+mova za0h.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-00000001-10000000
+// CHECK-INST: mov za0h.b[w12, 0:1], { z12.b, z13.b }
+// CHECK-ENCODING: [0x80,0x01,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040180 <unknown>
+
+mova za0h.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-01000000-00000001
+// CHECK-INST: mov za0h.b[w14, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0x40,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044001 <unknown>
+
+mova za0h.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-00000010-11000101
+// CHECK-INST: mov za0h.b[w12, 10:11], { z22.b, z23.b }
+// CHECK-ENCODING: [0xc5,0x02,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00402c5 <unknown>
+
+mova za0h.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-01100001-00000010
+// CHECK-INST: mov za0h.b[w15, 4:5], { z8.b, z9.b }
+// CHECK-ENCODING: [0x02,0x61,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046102 <unknown>
+
+mova za0h.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-00100001-10000111
+// CHECK-INST: mov za0h.b[w13, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0x21,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042187 <unknown>
+
+// Aliases
+
+mov za0h.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-00000000-00000000
+// CHECK-INST: mov za0h.b[w12, 0:1], { z0.b, z1.b }
+// CHECK-ENCODING: [0x00,0x00,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040000 <unknown>
+
+mov za0h.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-01000001-01000101
+// CHECK-INST: mov za0h.b[w14, 10:11], { z10.b, z11.b }
+// CHECK-ENCODING: [0x45,0x41,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044145 <unknown>
+
+mov za0h.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-01100001-10000111
+// CHECK-INST: mov za0h.b[w15, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0x61,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046187 <unknown>
+
+mov za0h.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-01100011-11000111
+// CHECK-INST: mov za0h.b[w15, 14:15], { z30.b, z31.b }
+// CHECK-ENCODING: [0xc7,0x63,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00463c7 <unknown>
+
+mov za0h.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-00000010-00000101
+// CHECK-INST: mov za0h.b[w12, 10:11], { z16.b, z17.b }
+// CHECK-ENCODING: [0x05,0x02,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040205 <unknown>
+
+mov za0h.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-00000000-00000001
+// CHECK-INST: mov za0h.b[w12, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0x00,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040001 <unknown>
+
+mov za0h.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-01000010-01000000
+// CHECK-INST: mov za0h.b[w14, 0:1], { z18.b, z19.b }
+// CHECK-ENCODING: [0x40,0x42,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044240 <unknown>
+
+mov za0h.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-00000001-10000000
+// CHECK-INST: mov za0h.b[w12, 0:1], { z12.b, z13.b }
+// CHECK-ENCODING: [0x80,0x01,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040180 <unknown>
+
+mov za0h.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-01000000-00000001
+// CHECK-INST: mov za0h.b[w14, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0x40,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044001 <unknown>
+
+mov za0h.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-00000010-11000101
+// CHECK-INST: mov za0h.b[w12, 10:11], { z22.b, z23.b }
+// CHECK-ENCODING: [0xc5,0x02,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00402c5 <unknown>
+
+mov za0h.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-01100001-00000010
+// CHECK-INST: mov za0h.b[w15, 4:5], { z8.b, z9.b }
+// CHECK-ENCODING: [0x02,0x61,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046102 <unknown>
+
+mov za0h.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-00100001-10000111
+// CHECK-INST: mov za0h.b[w13, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0x21,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042187 <unknown>
+
+
+mova za0v.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-10000000-00000000
+// CHECK-INST: mov za0v.b[w12, 0:1], { z0.b, z1.b }
+// CHECK-ENCODING: [0x00,0x80,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048000 <unknown>
+
+mova za0v.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-11000001-01000101
+// CHECK-INST: mov za0v.b[w14, 10:11], { z10.b, z11.b }
+// CHECK-ENCODING: [0x45,0xc1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c145 <unknown>
+
+mova za0v.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-11100001-10000111
+// CHECK-INST: mov za0v.b[w15, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0xe1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e187 <unknown>
+
+mova za0v.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-11100011-11000111
+// CHECK-INST: mov za0v.b[w15, 14:15], { z30.b, z31.b }
+// CHECK-ENCODING: [0xc7,0xe3,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e3c7 <unknown>
+
+mova za0v.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-10000010-00000101
+// CHECK-INST: mov za0v.b[w12, 10:11], { z16.b, z17.b }
+// CHECK-ENCODING: [0x05,0x82,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048205 <unknown>
+
+mova za0v.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-10000000-00000001
+// CHECK-INST: mov za0v.b[w12, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0x80,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048001 <unknown>
+
+mova za0v.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-11000010-01000000
+// CHECK-INST: mov za0v.b[w14, 0:1], { z18.b, z19.b }
+// CHECK-ENCODING: [0x40,0xc2,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c240 <unknown>
+
+mova za0v.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-10000001-10000000
+// CHECK-INST: mov za0v.b[w12, 0:1], { z12.b, z13.b }
+// CHECK-ENCODING: [0x80,0x81,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048180 <unknown>
+
+mova za0v.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-11000000-00000001
+// CHECK-INST: mov za0v.b[w14, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0xc0,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c001 <unknown>
+
+mova za0v.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-10000010-11000101
+// CHECK-INST: mov za0v.b[w12, 10:11], { z22.b, z23.b }
+// CHECK-ENCODING: [0xc5,0x82,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00482c5 <unknown>
+
+mova za0v.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-11100001-00000010
+// CHECK-INST: mov za0v.b[w15, 4:5], { z8.b, z9.b }
+// CHECK-ENCODING: [0x02,0xe1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e102 <unknown>
+
+mova za0v.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-10100001-10000111
+// CHECK-INST: mov za0v.b[w13, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0xa1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004a187 <unknown>
+
+// Aliases
+
+mov za0v.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-10000000-00000000
+// CHECK-INST: mov za0v.b[w12, 0:1], { z0.b, z1.b }
+// CHECK-ENCODING: [0x00,0x80,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048000 <unknown>
+
+mov za0v.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-11000001-01000101
+// CHECK-INST: mov za0v.b[w14, 10:11], { z10.b, z11.b }
+// CHECK-ENCODING: [0x45,0xc1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c145 <unknown>
+
+mov za0v.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-11100001-10000111
+// CHECK-INST: mov za0v.b[w15, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0xe1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e187 <unknown>
+
+mov za0v.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-11100011-11000111
+// CHECK-INST: mov za0v.b[w15, 14:15], { z30.b, z31.b }
+// CHECK-ENCODING: [0xc7,0xe3,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e3c7 <unknown>
+
+mov za0v.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-10000010-00000101
+// CHECK-INST: mov za0v.b[w12, 10:11], { z16.b, z17.b }
+// CHECK-ENCODING: [0x05,0x82,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048205 <unknown>
+
+mov za0v.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-10000000-00000001
+// CHECK-INST: mov za0v.b[w12, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0x80,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048001 <unknown>
+
+mov za0v.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-11000010-01000000
+// CHECK-INST: mov za0v.b[w14, 0:1], { z18.b, z19.b }
+// CHECK-ENCODING: [0x40,0xc2,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c240 <unknown>
+
+mov za0v.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-10000001-10000000
+// CHECK-INST: mov za0v.b[w12, 0:1], { z12.b, z13.b }
+// CHECK-ENCODING: [0x80,0x81,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048180 <unknown>
+
+mov za0v.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-11000000-00000001
+// CHECK-INST: mov za0v.b[w14, 2:3], { z0.b, z1.b }
+// CHECK-ENCODING: [0x01,0xc0,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c001 <unknown>
+
+mov za0v.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-10000010-11000101
+// CHECK-INST: mov za0v.b[w12, 10:11], { z22.b, z23.b }
+// CHECK-ENCODING: [0xc5,0x82,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c00482c5 <unknown>
+
+mov za0v.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-11100001-00000010
+// CHECK-INST: mov za0v.b[w15, 4:5], { z8.b, z9.b }
+// CHECK-ENCODING: [0x02,0xe1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e102 <unknown>
+
+mov za0v.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-10100001-10000111
+// CHECK-INST: mov za0v.b[w13, 14:15], { z12.b, z13.b }
+// CHECK-ENCODING: [0x87,0xa1,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004a187 <unknown>
+
+
+mova {z0.h - z3.h}, za0h.h[w12, 0:3] // 11000000-01000110-00000100-00000000
+// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460400 <unknown>
+
+mova {z20.h - z23.h}, za1h.h[w14, 0:3] // 11000000-01000110-01000100-01010100
+// CHECK-INST: mov { z20.h - z23.h }, za1h.h[w14, 0:3]
+// CHECK-ENCODING: [0x54,0x44,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464454 <unknown>
+
+mova {z20.h - z23.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00110100
+// CHECK-INST: mov { z20.h - z23.h }, za0h.h[w15, 4:7]
+// CHECK-ENCODING: [0x34,0x64,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0466434 <unknown>
+
+mova {z28.h - z31.h}, za1h.h[w15, 4:7] // 11000000-01000110-01100100-01111100
+// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w15, 4:7]
+// CHECK-ENCODING: [0x7c,0x64,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046647c <unknown>
+
+mova {z4.h - z7.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100100
+// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460424 <unknown>
+
+mova {z0.h - z3.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460420 <unknown>
+
+mova {z24.h - z27.h}, za1h.h[w14, 4:7] // 11000000-01000110-01000100-01111000
+// CHECK-INST: mov { z24.h - z27.h }, za1h.h[w14, 4:7]
+// CHECK-ENCODING: [0x78,0x44,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464478 <unknown>
+
+mova {z16.h - z19.h}, za0h.h[w14, 4:7] // 11000000-01000110-01000100-00110000
+// CHECK-INST: mov { z16.h - z19.h }, za0h.h[w14, 4:7]
+// CHECK-ENCODING: [0x30,0x44,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464430 <unknown>
+
+mova {z28.h - z31.h}, za1h.h[w12, 0:3] // 11000000-01000110-00000100-01011100
+// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046045c <unknown>
+
+mova {z0.h - z3.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w15, 4:7]
+// CHECK-ENCODING: [0x20,0x64,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0466420 <unknown>
+
+mova {z4.h - z7.h}, za0h.h[w13, 0:3] // 11000000-01000110-00100100-00000100
+// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w13, 0:3]
+// CHECK-ENCODING: [0x04,0x24,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0462404 <unknown>
+
+// Aliases
+
+mov {z0.h - z3.h}, za0h.h[w12, 0:3] // 11000000-01000110-00000100-00000000
+// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460400 <unknown>
+
+mov {z20.h - z23.h}, za1h.h[w14, 0:3] // 11000000-01000110-01000100-01010100
+// CHECK-INST: mov { z20.h - z23.h }, za1h.h[w14, 0:3]
+// CHECK-ENCODING: [0x54,0x44,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464454 <unknown>
+
+mov {z20.h - z23.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00110100
+// CHECK-INST: mov { z20.h - z23.h }, za0h.h[w15, 4:7]
+// CHECK-ENCODING: [0x34,0x64,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0466434 <unknown>
+
+mov {z28.h - z31.h}, za1h.h[w15, 4:7] // 11000000-01000110-01100100-01111100
+// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w15, 4:7]
+// CHECK-ENCODING: [0x7c,0x64,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046647c <unknown>
+
+mov {z4.h - z7.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100100
+// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460424 <unknown>
+
+mov {z0.h - z3.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0460420 <unknown>
+
+mov {z24.h - z27.h}, za1h.h[w14, 4:7] // 11000000-01000110-01000100-01111000
+// CHECK-INST: mov { z24.h - z27.h }, za1h.h[w14, 4:7]
+// CHECK-ENCODING: [0x78,0x44,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464478 <unknown>
+
+mov {z16.h - z19.h}, za0h.h[w14, 4:7] // 11000000-01000110-01000100-00110000
+// CHECK-INST: mov { z16.h - z19.h }, za0h.h[w14, 4:7]
+// CHECK-ENCODING: [0x30,0x44,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0464430 <unknown>
+
+mov {z28.h - z31.h}, za1h.h[w12, 0:3] // 11000000-01000110-00000100-01011100
+// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x04,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046045c <unknown>
+
+mov {z0.h - z3.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w15, 4:7]
+// CHECK-ENCODING: [0x20,0x64,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0466420 <unknown>
+
+mov {z4.h - z7.h}, za0h.h[w13, 0:3] // 11000000-01000110-00100100-00000100
+// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w13, 0:3]
+// CHECK-ENCODING: [0x04,0x24,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0462404 <unknown>
+
+
+mova {z0.h - z3.h}, za0v.h[w12, 0:3] // 11000000-01000110-10000100-00000000
+// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468400 <unknown>
+
+mova {z20.h - z23.h}, za1v.h[w14, 0:3] // 11000000-01000110-11000100-01010100
+// CHECK-INST: mov { z20.h - z23.h }, za1v.h[w14, 0:3]
+// CHECK-ENCODING: [0x54,0xc4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c454 <unknown>
+
+mova {z20.h - z23.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00110100
+// CHECK-INST: mov { z20.h - z23.h }, za0v.h[w15, 4:7]
+// CHECK-ENCODING: [0x34,0xe4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e434 <unknown>
+
+mova {z28.h - z31.h}, za1v.h[w15, 4:7] // 11000000-01000110-11100100-01111100
+// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w15, 4:7]
+// CHECK-ENCODING: [0x7c,0xe4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e47c <unknown>
+
+mova {z4.h - z7.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100100
+// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468424 <unknown>
+
+mova {z0.h - z3.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468420 <unknown>
+
+mova {z24.h - z27.h}, za1v.h[w14, 4:7] // 11000000-01000110-11000100-01111000
+// CHECK-INST: mov { z24.h - z27.h }, za1v.h[w14, 4:7]
+// CHECK-ENCODING: [0x78,0xc4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c478 <unknown>
+
+mova {z16.h - z19.h}, za0v.h[w14, 4:7] // 11000000-01000110-11000100-00110000
+// CHECK-INST: mov { z16.h - z19.h }, za0v.h[w14, 4:7]
+// CHECK-ENCODING: [0x30,0xc4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c430 <unknown>
+
+mova {z28.h - z31.h}, za1v.h[w12, 0:3] // 11000000-01000110-10000100-01011100
+// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046845c <unknown>
+
+mova {z0.h - z3.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w15, 4:7]
+// CHECK-ENCODING: [0x20,0xe4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e420 <unknown>
+
+mova {z4.h - z7.h}, za0v.h[w13, 0:3] // 11000000-01000110-10100100-00000100
+// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w13, 0:3]
+// CHECK-ENCODING: [0x04,0xa4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046a404 <unknown>
+
+// Aliases
+
+mov {z0.h - z3.h}, za0v.h[w12, 0:3] // 11000000-01000110-10000100-00000000
+// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468400 <unknown>
+
+mov {z20.h - z23.h}, za1v.h[w14, 0:3] // 11000000-01000110-11000100-01010100
+// CHECK-INST: mov { z20.h - z23.h }, za1v.h[w14, 0:3]
+// CHECK-ENCODING: [0x54,0xc4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c454 <unknown>
+
+mov {z20.h - z23.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00110100
+// CHECK-INST: mov { z20.h - z23.h }, za0v.h[w15, 4:7]
+// CHECK-ENCODING: [0x34,0xe4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e434 <unknown>
+
+mov {z28.h - z31.h}, za1v.h[w15, 4:7] // 11000000-01000110-11100100-01111100
+// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w15, 4:7]
+// CHECK-ENCODING: [0x7c,0xe4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e47c <unknown>
+
+mov {z4.h - z7.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100100
+// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468424 <unknown>
+
+mov {z0.h - z3.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0468420 <unknown>
+
+mov {z24.h - z27.h}, za1v.h[w14, 4:7] // 11000000-01000110-11000100-01111000
+// CHECK-INST: mov { z24.h - z27.h }, za1v.h[w14, 4:7]
+// CHECK-ENCODING: [0x78,0xc4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c478 <unknown>
+
+mov {z16.h - z19.h}, za0v.h[w14, 4:7] // 11000000-01000110-11000100-00110000
+// CHECK-INST: mov { z16.h - z19.h }, za0v.h[w14, 4:7]
+// CHECK-ENCODING: [0x30,0xc4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046c430 <unknown>
+
+mov {z28.h - z31.h}, za1v.h[w12, 0:3] // 11000000-01000110-10000100-01011100
+// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x84,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046845c <unknown>
+
+mov {z0.h - z3.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00100000
+// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w15, 4:7]
+// CHECK-ENCODING: [0x20,0xe4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046e420 <unknown>
+
+mov {z4.h - z7.h}, za0v.h[w13, 0:3] // 11000000-01000110-10100100-00000100
+// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w13, 0:3]
+// CHECK-ENCODING: [0x04,0xa4,0x46,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c046a404 <unknown>
+
+
+mova za0h.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-00000100-00000000
+// CHECK-INST: mov za0h.h[w12, 0:3], { z0.h - z3.h }
+// CHECK-ENCODING: [0x00,0x04,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440400 <unknown>
+
+mova za0h.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-01000101-00000001
+// CHECK-INST: mov za0h.h[w14, 4:7], { z8.h - z11.h }
+// CHECK-ENCODING: [0x01,0x45,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444501 <unknown>
+
+mova za1h.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-01100101-10000011
+// CHECK-INST: mov za1h.h[w15, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0x65,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446583 <unknown>
+
+mova za1h.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-01100111-10000011
+// CHECK-INST: mov za1h.h[w15, 4:7], { z28.h - z31.h }
+// CHECK-ENCODING: [0x83,0x67,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446783 <unknown>
+
+mova za0h.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-00000110-00000001
+// CHECK-INST: mov za0h.h[w12, 4:7], { z16.h - z19.h }
+// CHECK-ENCODING: [0x01,0x06,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440601 <unknown>
+
+mova za0h.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-00000100-00000001
+// CHECK-INST: mov za0h.h[w12, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0x04,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440401 <unknown>
+
+mova za0h.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-01000110-00000000
+// CHECK-INST: mov za0h.h[w14, 0:3], { z16.h - z19.h }
+// CHECK-ENCODING: [0x00,0x46,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444600 <unknown>
+
+mova za0h.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-00000101-10000000
+// CHECK-INST: mov za0h.h[w12, 0:3], { z12.h - z15.h }
+// CHECK-ENCODING: [0x80,0x05,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440580 <unknown>
+
+mova za0h.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-01000100-00000001
+// CHECK-INST: mov za0h.h[w14, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0x44,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444401 <unknown>
+
+mova za0h.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-00000110-10000001
+// CHECK-INST: mov za0h.h[w12, 4:7], { z20.h - z23.h }
+// CHECK-ENCODING: [0x81,0x06,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440681 <unknown>
+
+mova za1h.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-01100101-00000010
+// CHECK-INST: mov za1h.h[w15, 0:3], { z8.h - z11.h }
+// CHECK-ENCODING: [0x02,0x65,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446502 <unknown>
+
+mova za1h.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-00100101-10000011
+// CHECK-INST: mov za1h.h[w13, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0x25,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0442583 <unknown>
+
+// Aliases
+
+mov za0h.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-00000100-00000000
+// CHECK-INST: mov za0h.h[w12, 0:3], { z0.h - z3.h }
+// CHECK-ENCODING: [0x00,0x04,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440400 <unknown>
+
+mov za0h.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-01000101-00000001
+// CHECK-INST: mov za0h.h[w14, 4:7], { z8.h - z11.h }
+// CHECK-ENCODING: [0x01,0x45,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444501 <unknown>
+
+mov za1h.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-01100101-10000011
+// CHECK-INST: mov za1h.h[w15, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0x65,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446583 <unknown>
+
+mov za1h.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-01100111-10000011
+// CHECK-INST: mov za1h.h[w15, 4:7], { z28.h - z31.h }
+// CHECK-ENCODING: [0x83,0x67,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446783 <unknown>
+
+mov za0h.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-00000110-00000001
+// CHECK-INST: mov za0h.h[w12, 4:7], { z16.h - z19.h }
+// CHECK-ENCODING: [0x01,0x06,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440601 <unknown>
+
+mov za0h.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-00000100-00000001
+// CHECK-INST: mov za0h.h[w12, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0x04,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440401 <unknown>
+
+mov za0h.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-01000110-00000000
+// CHECK-INST: mov za0h.h[w14, 0:3], { z16.h - z19.h }
+// CHECK-ENCODING: [0x00,0x46,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444600 <unknown>
+
+mov za0h.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-00000101-10000000
+// CHECK-INST: mov za0h.h[w12, 0:3], { z12.h - z15.h }
+// CHECK-ENCODING: [0x80,0x05,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440580 <unknown>
+
+mov za0h.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-01000100-00000001
+// CHECK-INST: mov za0h.h[w14, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0x44,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0444401 <unknown>
+
+mov za0h.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-00000110-10000001
+// CHECK-INST: mov za0h.h[w12, 4:7], { z20.h - z23.h }
+// CHECK-ENCODING: [0x81,0x06,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0440681 <unknown>
+
+mov za1h.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-01100101-00000010
+// CHECK-INST: mov za1h.h[w15, 0:3], { z8.h - z11.h }
+// CHECK-ENCODING: [0x02,0x65,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0446502 <unknown>
+
+mov za1h.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-00100101-10000011
+// CHECK-INST: mov za1h.h[w13, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0x25,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0442583 <unknown>
+
+
+mova za0v.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-10000100-00000000
+// CHECK-INST: mov za0v.h[w12, 0:3], { z0.h - z3.h }
+// CHECK-ENCODING: [0x00,0x84,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448400 <unknown>
+
+mova za0v.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-11000101-00000001
+// CHECK-INST: mov za0v.h[w14, 4:7], { z8.h - z11.h }
+// CHECK-ENCODING: [0x01,0xc5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c501 <unknown>
+
+mova za1v.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-11100101-10000011
+// CHECK-INST: mov za1v.h[w15, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0xe5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e583 <unknown>
+
+mova za1v.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-11100111-10000011
+// CHECK-INST: mov za1v.h[w15, 4:7], { z28.h - z31.h }
+// CHECK-ENCODING: [0x83,0xe7,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e783 <unknown>
+
+mova za0v.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-10000110-00000001
+// CHECK-INST: mov za0v.h[w12, 4:7], { z16.h - z19.h }
+// CHECK-ENCODING: [0x01,0x86,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448601 <unknown>
+
+mova za0v.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-10000100-00000001
+// CHECK-INST: mov za0v.h[w12, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0x84,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448401 <unknown>
+
+mova za0v.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-11000110-00000000
+// CHECK-INST: mov za0v.h[w14, 0:3], { z16.h - z19.h }
+// CHECK-ENCODING: [0x00,0xc6,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c600 <unknown>
+
+mova za0v.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-10000101-10000000
+// CHECK-INST: mov za0v.h[w12, 0:3], { z12.h - z15.h }
+// CHECK-ENCODING: [0x80,0x85,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448580 <unknown>
+
+mova za0v.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-11000100-00000001
+// CHECK-INST: mov za0v.h[w14, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0xc4,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c401 <unknown>
+
+mova za0v.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-10000110-10000001
+// CHECK-INST: mov za0v.h[w12, 4:7], { z20.h - z23.h }
+// CHECK-ENCODING: [0x81,0x86,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448681 <unknown>
+
+mova za1v.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-11100101-00000010
+// CHECK-INST: mov za1v.h[w15, 0:3], { z8.h - z11.h }
+// CHECK-ENCODING: [0x02,0xe5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e502 <unknown>
+
+mova za1v.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-10100101-10000011
+// CHECK-INST: mov za1v.h[w13, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0xa5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044a583 <unknown>
+
+// Aliases
+
+mov za0v.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-10000100-00000000
+// CHECK-INST: mov za0v.h[w12, 0:3], { z0.h - z3.h }
+// CHECK-ENCODING: [0x00,0x84,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448400 <unknown>
+
+mov za0v.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-11000101-00000001
+// CHECK-INST: mov za0v.h[w14, 4:7], { z8.h - z11.h }
+// CHECK-ENCODING: [0x01,0xc5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c501 <unknown>
+
+mov za1v.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-11100101-10000011
+// CHECK-INST: mov za1v.h[w15, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0xe5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e583 <unknown>
+
+mov za1v.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-11100111-10000011
+// CHECK-INST: mov za1v.h[w15, 4:7], { z28.h - z31.h }
+// CHECK-ENCODING: [0x83,0xe7,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e783 <unknown>
+
+mov za0v.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-10000110-00000001
+// CHECK-INST: mov za0v.h[w12, 4:7], { z16.h - z19.h }
+// CHECK-ENCODING: [0x01,0x86,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448601 <unknown>
+
+mov za0v.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-10000100-00000001
+// CHECK-INST: mov za0v.h[w12, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0x84,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448401 <unknown>
+
+mov za0v.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-11000110-00000000
+// CHECK-INST: mov za0v.h[w14, 0:3], { z16.h - z19.h }
+// CHECK-ENCODING: [0x00,0xc6,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c600 <unknown>
+
+mov za0v.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-10000101-10000000
+// CHECK-INST: mov za0v.h[w12, 0:3], { z12.h - z15.h }
+// CHECK-ENCODING: [0x80,0x85,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448580 <unknown>
+
+mov za0v.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-11000100-00000001
+// CHECK-INST: mov za0v.h[w14, 4:7], { z0.h - z3.h }
+// CHECK-ENCODING: [0x01,0xc4,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044c401 <unknown>
+
+mov za0v.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-10000110-10000001
+// CHECK-INST: mov za0v.h[w12, 4:7], { z20.h - z23.h }
+// CHECK-ENCODING: [0x81,0x86,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0448681 <unknown>
+
+mov za1v.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-11100101-00000010
+// CHECK-INST: mov za1v.h[w15, 0:3], { z8.h - z11.h }
+// CHECK-ENCODING: [0x02,0xe5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044e502 <unknown>
+
+mov za1v.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-10100101-10000011
+// CHECK-INST: mov za1v.h[w13, 4:7], { z12.h - z15.h }
+// CHECK-ENCODING: [0x83,0xa5,0x44,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c044a583 <unknown>
+
+
+mova {z0.s - z3.s}, za0h.s[w12, 0:3] // 11000000-10000110-00000100-00000000
+// CHECK-INST: mov { z0.s - z3.s }, za0h.s[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860400 <unknown>
+
+mova {z20.s - z23.s}, za2h.s[w14, 0:3] // 11000000-10000110-01000100-01010100
+// CHECK-INST: mov { z20.s - z23.s }, za2h.s[w14, 0:3]
+// CHECK-ENCODING: [0x54,0x44,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864454 <unknown>
+
+mova {z20.s - z23.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00110100
+// CHECK-INST: mov { z20.s - z23.s }, za1h.s[w15, 0:3]
+// CHECK-ENCODING: [0x34,0x64,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0866434 <unknown>
+
+mova {z28.s - z31.s}, za3h.s[w15, 0:3] // 11000000-10000110-01100100-01111100
+// CHECK-INST: mov { z28.s - z31.s }, za3h.s[w15, 0:3]
+// CHECK-ENCODING: [0x7c,0x64,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086647c <unknown>
+
+mova {z4.s - z7.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100100
+// CHECK-INST: mov { z4.s - z7.s }, za1h.s[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860424 <unknown>
+
+mova {z0.s - z3.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860420 <unknown>
+
+mova {z24.s - z27.s}, za3h.s[w14, 0:3] // 11000000-10000110-01000100-01111000
+// CHECK-INST: mov { z24.s - z27.s }, za3h.s[w14, 0:3]
+// CHECK-ENCODING: [0x78,0x44,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864478 <unknown>
+
+mova {z16.s - z19.s}, za1h.s[w14, 0:3] // 11000000-10000110-01000100-00110000
+// CHECK-INST: mov { z16.s - z19.s }, za1h.s[w14, 0:3]
+// CHECK-ENCODING: [0x30,0x44,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864430 <unknown>
+
+mova {z28.s - z31.s}, za2h.s[w12, 0:3] // 11000000-10000110-00000100-01011100
+// CHECK-INST: mov { z28.s - z31.s }, za2h.s[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086045c <unknown>
+
+mova {z0.s - z3.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w15, 0:3]
+// CHECK-ENCODING: [0x20,0x64,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0866420 <unknown>
+
+mova {z4.s - z7.s}, za0h.s[w13, 0:3] // 11000000-10000110-00100100-00000100
+// CHECK-INST: mov { z4.s - z7.s }, za0h.s[w13, 0:3]
+// CHECK-ENCODING: [0x04,0x24,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0862404 <unknown>
+
+// Aliases
+
+mov {z0.s - z3.s}, za0h.s[w12, 0:3] // 11000000-10000110-00000100-00000000
+// CHECK-INST: mov { z0.s - z3.s }, za0h.s[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860400 <unknown>
+
+mov {z20.s - z23.s}, za2h.s[w14, 0:3] // 11000000-10000110-01000100-01010100
+// CHECK-INST: mov { z20.s - z23.s }, za2h.s[w14, 0:3]
+// CHECK-ENCODING: [0x54,0x44,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864454 <unknown>
+
+mov {z20.s - z23.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00110100
+// CHECK-INST: mov { z20.s - z23.s }, za1h.s[w15, 0:3]
+// CHECK-ENCODING: [0x34,0x64,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0866434 <unknown>
+
+mov {z28.s - z31.s}, za3h.s[w15, 0:3] // 11000000-10000110-01100100-01111100
+// CHECK-INST: mov { z28.s - z31.s }, za3h.s[w15, 0:3]
+// CHECK-ENCODING: [0x7c,0x64,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086647c <unknown>
+
+mov {z4.s - z7.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100100
+// CHECK-INST: mov { z4.s - z7.s }, za1h.s[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860424 <unknown>
+
+mov {z0.s - z3.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0860420 <unknown>
+
+mov {z24.s - z27.s}, za3h.s[w14, 0:3] // 11000000-10000110-01000100-01111000
+// CHECK-INST: mov { z24.s - z27.s }, za3h.s[w14, 0:3]
+// CHECK-ENCODING: [0x78,0x44,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864478 <unknown>
+
+mov {z16.s - z19.s}, za1h.s[w14, 0:3] // 11000000-10000110-01000100-00110000
+// CHECK-INST: mov { z16.s - z19.s }, za1h.s[w14, 0:3]
+// CHECK-ENCODING: [0x30,0x44,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0864430 <unknown>
+
+mov {z28.s - z31.s}, za2h.s[w12, 0:3] // 11000000-10000110-00000100-01011100
+// CHECK-INST: mov { z28.s - z31.s }, za2h.s[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x04,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086045c <unknown>
+
+mov {z0.s - z3.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w15, 0:3]
+// CHECK-ENCODING: [0x20,0x64,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0866420 <unknown>
+
+mov {z4.s - z7.s}, za0h.s[w13, 0:3] // 11000000-10000110-00100100-00000100
+// CHECK-INST: mov { z4.s - z7.s }, za0h.s[w13, 0:3]
+// CHECK-ENCODING: [0x04,0x24,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0862404 <unknown>
+
+
+mova {z0.s - z3.s}, za0v.s[w12, 0:3] // 11000000-10000110-10000100-00000000
+// CHECK-INST: mov { z0.s - z3.s }, za0v.s[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868400 <unknown>
+
+mova {z20.s - z23.s}, za2v.s[w14, 0:3] // 11000000-10000110-11000100-01010100
+// CHECK-INST: mov { z20.s - z23.s }, za2v.s[w14, 0:3]
+// CHECK-ENCODING: [0x54,0xc4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c454 <unknown>
+
+mova {z20.s - z23.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00110100
+// CHECK-INST: mov { z20.s - z23.s }, za1v.s[w15, 0:3]
+// CHECK-ENCODING: [0x34,0xe4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e434 <unknown>
+
+mova {z28.s - z31.s}, za3v.s[w15, 0:3] // 11000000-10000110-11100100-01111100
+// CHECK-INST: mov { z28.s - z31.s }, za3v.s[w15, 0:3]
+// CHECK-ENCODING: [0x7c,0xe4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e47c <unknown>
+
+mova {z4.s - z7.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100100
+// CHECK-INST: mov { z4.s - z7.s }, za1v.s[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868424 <unknown>
+
+mova {z0.s - z3.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868420 <unknown>
+
+mova {z24.s - z27.s}, za3v.s[w14, 0:3] // 11000000-10000110-11000100-01111000
+// CHECK-INST: mov { z24.s - z27.s }, za3v.s[w14, 0:3]
+// CHECK-ENCODING: [0x78,0xc4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c478 <unknown>
+
+mova {z16.s - z19.s}, za1v.s[w14, 0:3] // 11000000-10000110-11000100-00110000
+// CHECK-INST: mov { z16.s - z19.s }, za1v.s[w14, 0:3]
+// CHECK-ENCODING: [0x30,0xc4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c430 <unknown>
+
+mova {z28.s - z31.s}, za2v.s[w12, 0:3] // 11000000-10000110-10000100-01011100
+// CHECK-INST: mov { z28.s - z31.s }, za2v.s[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086845c <unknown>
+
+mova {z0.s - z3.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w15, 0:3]
+// CHECK-ENCODING: [0x20,0xe4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e420 <unknown>
+
+mova {z4.s - z7.s}, za0v.s[w13, 0:3] // 11000000-10000110-10100100-00000100
+// CHECK-INST: mov { z4.s - z7.s }, za0v.s[w13, 0:3]
+// CHECK-ENCODING: [0x04,0xa4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086a404 <unknown>
+
+// Aliases
+
+mov {z0.s - z3.s}, za0v.s[w12, 0:3] // 11000000-10000110-10000100-00000000
+// CHECK-INST: mov { z0.s - z3.s }, za0v.s[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868400 <unknown>
+
+mov {z20.s - z23.s}, za2v.s[w14, 0:3] // 11000000-10000110-11000100-01010100
+// CHECK-INST: mov { z20.s - z23.s }, za2v.s[w14, 0:3]
+// CHECK-ENCODING: [0x54,0xc4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c454 <unknown>
+
+mov {z20.s - z23.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00110100
+// CHECK-INST: mov { z20.s - z23.s }, za1v.s[w15, 0:3]
+// CHECK-ENCODING: [0x34,0xe4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e434 <unknown>
+
+mov {z28.s - z31.s}, za3v.s[w15, 0:3] // 11000000-10000110-11100100-01111100
+// CHECK-INST: mov { z28.s - z31.s }, za3v.s[w15, 0:3]
+// CHECK-ENCODING: [0x7c,0xe4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e47c <unknown>
+
+mov {z4.s - z7.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100100
+// CHECK-INST: mov { z4.s - z7.s }, za1v.s[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868424 <unknown>
+
+mov {z0.s - z3.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0868420 <unknown>
+
+mov {z24.s - z27.s}, za3v.s[w14, 0:3] // 11000000-10000110-11000100-01111000
+// CHECK-INST: mov { z24.s - z27.s }, za3v.s[w14, 0:3]
+// CHECK-ENCODING: [0x78,0xc4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c478 <unknown>
+
+mov {z16.s - z19.s}, za1v.s[w14, 0:3] // 11000000-10000110-11000100-00110000
+// CHECK-INST: mov { z16.s - z19.s }, za1v.s[w14, 0:3]
+// CHECK-ENCODING: [0x30,0xc4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086c430 <unknown>
+
+mov {z28.s - z31.s}, za2v.s[w12, 0:3] // 11000000-10000110-10000100-01011100
+// CHECK-INST: mov { z28.s - z31.s }, za2v.s[w12, 0:3]
+// CHECK-ENCODING: [0x5c,0x84,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086845c <unknown>
+
+mov {z0.s - z3.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00100000
+// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w15, 0:3]
+// CHECK-ENCODING: [0x20,0xe4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086e420 <unknown>
+
+mov {z4.s - z7.s}, za0v.s[w13, 0:3] // 11000000-10000110-10100100-00000100
+// CHECK-INST: mov { z4.s - z7.s }, za0v.s[w13, 0:3]
+// CHECK-ENCODING: [0x04,0xa4,0x86,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c086a404 <unknown>
+
+
+mova za0h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000000
+// CHECK-INST: mov za0h.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x00,0x04,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840400 <unknown>
+
+mova za1h.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-01000101-00000001
+// CHECK-INST: mov za1h.s[w14, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x01,0x45,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844501 <unknown>
+
+mova za3h.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-01100101-10000011
+// CHECK-INST: mov za3h.s[w15, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0x65,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846583 <unknown>
+
+mova za3h.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-01100111-10000011
+// CHECK-INST: mov za3h.s[w15, 0:3], { z28.s - z31.s }
+// CHECK-ENCODING: [0x83,0x67,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846783 <unknown>
+
+mova za1h.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-00000110-00000001
+// CHECK-INST: mov za1h.s[w12, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x01,0x06,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840601 <unknown>
+
+mova za1h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000001
+// CHECK-INST: mov za1h.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0x04,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840401 <unknown>
+
+mova za0h.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-01000110-00000000
+// CHECK-INST: mov za0h.s[w14, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x00,0x46,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844600 <unknown>
+
+mova za0h.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-00000101-10000000
+// CHECK-INST: mov za0h.s[w12, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x80,0x05,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840580 <unknown>
+
+mova za1h.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-01000100-00000001
+// CHECK-INST: mov za1h.s[w14, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0x44,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844401 <unknown>
+
+mova za1h.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-00000110-10000001
+// CHECK-INST: mov za1h.s[w12, 0:3], { z20.s - z23.s }
+// CHECK-ENCODING: [0x81,0x06,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840681 <unknown>
+
+mova za2h.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-01100101-00000010
+// CHECK-INST: mov za2h.s[w15, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x02,0x65,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846502 <unknown>
+
+mova za3h.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-00100101-10000011
+// CHECK-INST: mov za3h.s[w13, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0x25,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0842583 <unknown>
+
+// Aliases
+
+mov za0h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000000
+// CHECK-INST: mov za0h.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x00,0x04,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840400 <unknown>
+
+mov za1h.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-01000101-00000001
+// CHECK-INST: mov za1h.s[w14, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x01,0x45,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844501 <unknown>
+
+mov za3h.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-01100101-10000011
+// CHECK-INST: mov za3h.s[w15, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0x65,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846583 <unknown>
+
+mov za3h.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-01100111-10000011
+// CHECK-INST: mov za3h.s[w15, 0:3], { z28.s - z31.s }
+// CHECK-ENCODING: [0x83,0x67,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846783 <unknown>
+
+mov za1h.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-00000110-00000001
+// CHECK-INST: mov za1h.s[w12, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x01,0x06,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840601 <unknown>
+
+mov za1h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000001
+// CHECK-INST: mov za1h.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0x04,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840401 <unknown>
+
+mov za0h.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-01000110-00000000
+// CHECK-INST: mov za0h.s[w14, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x00,0x46,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844600 <unknown>
+
+mov za0h.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-00000101-10000000
+// CHECK-INST: mov za0h.s[w12, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x80,0x05,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840580 <unknown>
+
+mov za1h.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-01000100-00000001
+// CHECK-INST: mov za1h.s[w14, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0x44,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0844401 <unknown>
+
+mov za1h.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-00000110-10000001
+// CHECK-INST: mov za1h.s[w12, 0:3], { z20.s - z23.s }
+// CHECK-ENCODING: [0x81,0x06,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0840681 <unknown>
+
+mov za2h.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-01100101-00000010
+// CHECK-INST: mov za2h.s[w15, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x02,0x65,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0846502 <unknown>
+
+mov za3h.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-00100101-10000011
+// CHECK-INST: mov za3h.s[w13, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0x25,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0842583 <unknown>
+
+
+mova za0v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000000
+// CHECK-INST: mov za0v.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x00,0x84,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848400 <unknown>
+
+mova za1v.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-11000101-00000001
+// CHECK-INST: mov za1v.s[w14, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x01,0xc5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c501 <unknown>
+
+mova za3v.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-11100101-10000011
+// CHECK-INST: mov za3v.s[w15, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0xe5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e583 <unknown>
+
+mova za3v.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-11100111-10000011
+// CHECK-INST: mov za3v.s[w15, 0:3], { z28.s - z31.s }
+// CHECK-ENCODING: [0x83,0xe7,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e783 <unknown>
+
+mova za1v.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-10000110-00000001
+// CHECK-INST: mov za1v.s[w12, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x01,0x86,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848601 <unknown>
+
+mova za1v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000001
+// CHECK-INST: mov za1v.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0x84,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848401 <unknown>
+
+mova za0v.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-11000110-00000000
+// CHECK-INST: mov za0v.s[w14, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x00,0xc6,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c600 <unknown>
+
+mova za0v.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-10000101-10000000
+// CHECK-INST: mov za0v.s[w12, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x80,0x85,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848580 <unknown>
+
+mova za1v.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-11000100-00000001
+// CHECK-INST: mov za1v.s[w14, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0xc4,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c401 <unknown>
+
+mova za1v.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-10000110-10000001
+// CHECK-INST: mov za1v.s[w12, 0:3], { z20.s - z23.s }
+// CHECK-ENCODING: [0x81,0x86,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848681 <unknown>
+
+mova za2v.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-11100101-00000010
+// CHECK-INST: mov za2v.s[w15, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x02,0xe5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e502 <unknown>
+
+mova za3v.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-10100101-10000011
+// CHECK-INST: mov za3v.s[w13, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0xa5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084a583 <unknown>
+
+// Aliases
+
+mov za0v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000000
+// CHECK-INST: mov za0v.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x00,0x84,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848400 <unknown>
+
+mov za1v.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-11000101-00000001
+// CHECK-INST: mov za1v.s[w14, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x01,0xc5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c501 <unknown>
+
+mov za3v.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-11100101-10000011
+// CHECK-INST: mov za3v.s[w15, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0xe5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e583 <unknown>
+
+mov za3v.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-11100111-10000011
+// CHECK-INST: mov za3v.s[w15, 0:3], { z28.s - z31.s }
+// CHECK-ENCODING: [0x83,0xe7,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e783 <unknown>
+
+mov za1v.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-10000110-00000001
+// CHECK-INST: mov za1v.s[w12, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x01,0x86,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848601 <unknown>
+
+mov za1v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000001
+// CHECK-INST: mov za1v.s[w12, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0x84,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848401 <unknown>
+
+mov za0v.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-11000110-00000000
+// CHECK-INST: mov za0v.s[w14, 0:3], { z16.s - z19.s }
+// CHECK-ENCODING: [0x00,0xc6,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c600 <unknown>
+
+mov za0v.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-10000101-10000000
+// CHECK-INST: mov za0v.s[w12, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x80,0x85,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848580 <unknown>
+
+mov za1v.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-11000100-00000001
+// CHECK-INST: mov za1v.s[w14, 0:3], { z0.s - z3.s }
+// CHECK-ENCODING: [0x01,0xc4,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084c401 <unknown>
+
+mov za1v.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-10000110-10000001
+// CHECK-INST: mov za1v.s[w12, 0:3], { z20.s - z23.s }
+// CHECK-ENCODING: [0x81,0x86,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0848681 <unknown>
+
+mov za2v.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-11100101-00000010
+// CHECK-INST: mov za2v.s[w15, 0:3], { z8.s - z11.s }
+// CHECK-ENCODING: [0x02,0xe5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084e502 <unknown>
+
+mov za3v.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-10100101-10000011
+// CHECK-INST: mov za3v.s[w13, 0:3], { z12.s - z15.s }
+// CHECK-ENCODING: [0x83,0xa5,0x84,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c084a583 <unknown>
+
+
+mova {z0.d - z3.d}, za0h.d[w12, 0:3] // 11000000-11000110-00000100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za0h.d[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60400 <unknown>
+
+mova {z20.d - z23.d}, za2h.d[w14, 0:3] // 11000000-11000110-01000100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za2h.d[w14, 0:3]
+// CHECK-ENCODING: [0x54,0x44,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64454 <unknown>
+
+mova {z20.d - z23.d}, za5h.d[w15, 0:3] // 11000000-11000110-01100100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za5h.d[w15, 0:3]
+// CHECK-ENCODING: [0xb4,0x64,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c664b4 <unknown>
+
+mova {z28.d - z31.d}, za7h.d[w15, 0:3] // 11000000-11000110-01100100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za7h.d[w15, 0:3]
+// CHECK-ENCODING: [0xfc,0x64,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c664fc <unknown>
+
+mova {z4.d - z7.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za1h.d[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60424 <unknown>
+
+mova {z0.d - z3.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60420 <unknown>
+
+mova {z24.d - z27.d}, za3h.d[w14, 0:3] // 11000000-11000110-01000100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za3h.d[w14, 0:3]
+// CHECK-ENCODING: [0x78,0x44,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64478 <unknown>
+
+mova {z0.d - z3.d}, za4h.d[w12, 0:3] // 11000000-11000110-00000100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za4h.d[w12, 0:3]
+// CHECK-ENCODING: [0x80,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60480 <unknown>
+
+mova {z16.d - z19.d}, za1h.d[w14, 0:3] // 11000000-11000110-01000100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za1h.d[w14, 0:3]
+// CHECK-ENCODING: [0x30,0x44,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64430 <unknown>
+
+mova {z28.d - z31.d}, za6h.d[w12, 0:3] // 11000000-11000110-00000100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za6h.d[w12, 0:3]
+// CHECK-ENCODING: [0xdc,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c604dc <unknown>
+
+mova {z0.d - z3.d}, za1h.d[w15, 0:3] // 11000000-11000110-01100100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w15, 0:3]
+// CHECK-ENCODING: [0x20,0x64,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c66420 <unknown>
+
+mova {z4.d - z7.d}, za4h.d[w13, 0:3] // 11000000-11000110-00100100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za4h.d[w13, 0:3]
+// CHECK-ENCODING: [0x84,0x24,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c62484 <unknown>
+
+// Aliases
+
+mov {z0.d - z3.d}, za0h.d[w12, 0:3] // 11000000-11000110-00000100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za0h.d[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60400 <unknown>
+
+mov {z20.d - z23.d}, za2h.d[w14, 0:3] // 11000000-11000110-01000100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za2h.d[w14, 0:3]
+// CHECK-ENCODING: [0x54,0x44,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64454 <unknown>
+
+mov {z20.d - z23.d}, za5h.d[w15, 0:3] // 11000000-11000110-01100100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za5h.d[w15, 0:3]
+// CHECK-ENCODING: [0xb4,0x64,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c664b4 <unknown>
+
+mov {z28.d - z31.d}, za7h.d[w15, 0:3] // 11000000-11000110-01100100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za7h.d[w15, 0:3]
+// CHECK-ENCODING: [0xfc,0x64,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c664fc <unknown>
+
+mov {z4.d - z7.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za1h.d[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60424 <unknown>
+
+mov {z0.d - z3.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60420 <unknown>
+
+mov {z24.d - z27.d}, za3h.d[w14, 0:3] // 11000000-11000110-01000100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za3h.d[w14, 0:3]
+// CHECK-ENCODING: [0x78,0x44,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64478 <unknown>
+
+mov {z0.d - z3.d}, za4h.d[w12, 0:3] // 11000000-11000110-00000100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za4h.d[w12, 0:3]
+// CHECK-ENCODING: [0x80,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c60480 <unknown>
+
+mov {z16.d - z19.d}, za1h.d[w14, 0:3] // 11000000-11000110-01000100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za1h.d[w14, 0:3]
+// CHECK-ENCODING: [0x30,0x44,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c64430 <unknown>
+
+mov {z28.d - z31.d}, za6h.d[w12, 0:3] // 11000000-11000110-00000100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za6h.d[w12, 0:3]
+// CHECK-ENCODING: [0xdc,0x04,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c604dc <unknown>
+
+mov {z0.d - z3.d}, za1h.d[w15, 0:3] // 11000000-11000110-01100100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w15, 0:3]
+// CHECK-ENCODING: [0x20,0x64,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c66420 <unknown>
+
+mov {z4.d - z7.d}, za4h.d[w13, 0:3] // 11000000-11000110-00100100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za4h.d[w13, 0:3]
+// CHECK-ENCODING: [0x84,0x24,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c62484 <unknown>
+
+
+mova {z0.d - z3.d}, za0v.d[w12, 0:3] // 11000000-11000110-10000100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za0v.d[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68400 <unknown>
+
+mova {z20.d - z23.d}, za2v.d[w14, 0:3] // 11000000-11000110-11000100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za2v.d[w14, 0:3]
+// CHECK-ENCODING: [0x54,0xc4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c454 <unknown>
+
+mova {z20.d - z23.d}, za5v.d[w15, 0:3] // 11000000-11000110-11100100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za5v.d[w15, 0:3]
+// CHECK-ENCODING: [0xb4,0xe4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e4b4 <unknown>
+
+mova {z28.d - z31.d}, za7v.d[w15, 0:3] // 11000000-11000110-11100100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za7v.d[w15, 0:3]
+// CHECK-ENCODING: [0xfc,0xe4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e4fc <unknown>
+
+mova {z4.d - z7.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za1v.d[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68424 <unknown>
+
+mova {z0.d - z3.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68420 <unknown>
+
+mova {z24.d - z27.d}, za3v.d[w14, 0:3] // 11000000-11000110-11000100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za3v.d[w14, 0:3]
+// CHECK-ENCODING: [0x78,0xc4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c478 <unknown>
+
+mova {z0.d - z3.d}, za4v.d[w12, 0:3] // 11000000-11000110-10000100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za4v.d[w12, 0:3]
+// CHECK-ENCODING: [0x80,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68480 <unknown>
+
+mova {z16.d - z19.d}, za1v.d[w14, 0:3] // 11000000-11000110-11000100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za1v.d[w14, 0:3]
+// CHECK-ENCODING: [0x30,0xc4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c430 <unknown>
+
+mova {z28.d - z31.d}, za6v.d[w12, 0:3] // 11000000-11000110-10000100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za6v.d[w12, 0:3]
+// CHECK-ENCODING: [0xdc,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c684dc <unknown>
+
+mova {z0.d - z3.d}, za1v.d[w15, 0:3] // 11000000-11000110-11100100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w15, 0:3]
+// CHECK-ENCODING: [0x20,0xe4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e420 <unknown>
+
+mova {z4.d - z7.d}, za4v.d[w13, 0:3] // 11000000-11000110-10100100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za4v.d[w13, 0:3]
+// CHECK-ENCODING: [0x84,0xa4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6a484 <unknown>
+
+// Aliases
+
+mov {z0.d - z3.d}, za0v.d[w12, 0:3] // 11000000-11000110-10000100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za0v.d[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68400 <unknown>
+
+mov {z20.d - z23.d}, za2v.d[w14, 0:3] // 11000000-11000110-11000100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za2v.d[w14, 0:3]
+// CHECK-ENCODING: [0x54,0xc4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c454 <unknown>
+
+mov {z20.d - z23.d}, za5v.d[w15, 0:3] // 11000000-11000110-11100100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za5v.d[w15, 0:3]
+// CHECK-ENCODING: [0xb4,0xe4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e4b4 <unknown>
+
+mov {z28.d - z31.d}, za7v.d[w15, 0:3] // 11000000-11000110-11100100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za7v.d[w15, 0:3]
+// CHECK-ENCODING: [0xfc,0xe4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e4fc <unknown>
+
+mov {z4.d - z7.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za1v.d[w12, 0:3]
+// CHECK-ENCODING: [0x24,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68424 <unknown>
+
+mov {z0.d - z3.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w12, 0:3]
+// CHECK-ENCODING: [0x20,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68420 <unknown>
+
+mov {z24.d - z27.d}, za3v.d[w14, 0:3] // 11000000-11000110-11000100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za3v.d[w14, 0:3]
+// CHECK-ENCODING: [0x78,0xc4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c478 <unknown>
+
+mov {z0.d - z3.d}, za4v.d[w12, 0:3] // 11000000-11000110-10000100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za4v.d[w12, 0:3]
+// CHECK-ENCODING: [0x80,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c68480 <unknown>
+
+mov {z16.d - z19.d}, za1v.d[w14, 0:3] // 11000000-11000110-11000100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za1v.d[w14, 0:3]
+// CHECK-ENCODING: [0x30,0xc4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6c430 <unknown>
+
+mov {z28.d - z31.d}, za6v.d[w12, 0:3] // 11000000-11000110-10000100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za6v.d[w12, 0:3]
+// CHECK-ENCODING: [0xdc,0x84,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c684dc <unknown>
+
+mov {z0.d - z3.d}, za1v.d[w15, 0:3] // 11000000-11000110-11100100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w15, 0:3]
+// CHECK-ENCODING: [0x20,0xe4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6e420 <unknown>
+
+mov {z4.d - z7.d}, za4v.d[w13, 0:3] // 11000000-11000110-10100100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za4v.d[w13, 0:3]
+// CHECK-ENCODING: [0x84,0xa4,0xc6,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c6a484 <unknown>
+
+
+mova {z0.d - z3.d}, za.d[w8, 0, vgx4] // 11000000-00000110-00001100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 0, vgx4]
+// CHECK-ENCODING: [0x00,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c00 <unknown>
+
+mova {z0.d - z3.d}, za.d[w8, 0] // 11000000-00000110-00001100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 0, vgx4]
+// CHECK-ENCODING: [0x00,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c00 <unknown>
+
+mova {z20.d - z23.d}, za.d[w10, 2, vgx4] // 11000000-00000110-01001100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za.d[w10, 2, vgx4]
+// CHECK-ENCODING: [0x54,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c54 <unknown>
+
+mova {z20.d - z23.d}, za.d[w10, 2] // 11000000-00000110-01001100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za.d[w10, 2, vgx4]
+// CHECK-ENCODING: [0x54,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c54 <unknown>
+
+mova {z20.d - z23.d}, za.d[w11, 5, vgx4] // 11000000-00000110-01101100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za.d[w11, 5, vgx4]
+// CHECK-ENCODING: [0xb4,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066cb4 <unknown>
+
+mova {z20.d - z23.d}, za.d[w11, 5] // 11000000-00000110-01101100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za.d[w11, 5, vgx4]
+// CHECK-ENCODING: [0xb4,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066cb4 <unknown>
+
+mova {z28.d - z31.d}, za.d[w11, 7, vgx4] // 11000000-00000110-01101100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za.d[w11, 7, vgx4]
+// CHECK-ENCODING: [0xfc,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066cfc <unknown>
+
+mova {z28.d - z31.d}, za.d[w11, 7] // 11000000-00000110-01101100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za.d[w11, 7, vgx4]
+// CHECK-ENCODING: [0xfc,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066cfc <unknown>
+
+mova {z4.d - z7.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za.d[w8, 1, vgx4]
+// CHECK-ENCODING: [0x24,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c24 <unknown>
+
+mova {z4.d - z7.d}, za.d[w8, 1] // 11000000-00000110-00001100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za.d[w8, 1, vgx4]
+// CHECK-ENCODING: [0x24,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c24 <unknown>
+
+mova {z0.d - z3.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 1, vgx4]
+// CHECK-ENCODING: [0x20,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c20 <unknown>
+
+mova {z0.d - z3.d}, za.d[w8, 1] // 11000000-00000110-00001100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 1, vgx4]
+// CHECK-ENCODING: [0x20,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c20 <unknown>
+
+mova {z24.d - z27.d}, za.d[w10, 3, vgx4] // 11000000-00000110-01001100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za.d[w10, 3, vgx4]
+// CHECK-ENCODING: [0x78,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c78 <unknown>
+
+mova {z24.d - z27.d}, za.d[w10, 3] // 11000000-00000110-01001100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za.d[w10, 3, vgx4]
+// CHECK-ENCODING: [0x78,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c78 <unknown>
+
+mova {z0.d - z3.d}, za.d[w8, 4, vgx4] // 11000000-00000110-00001100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 4, vgx4]
+// CHECK-ENCODING: [0x80,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c80 <unknown>
+
+mova {z0.d - z3.d}, za.d[w8, 4] // 11000000-00000110-00001100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 4, vgx4]
+// CHECK-ENCODING: [0x80,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c80 <unknown>
+
+mova {z16.d - z19.d}, za.d[w10, 1, vgx4] // 11000000-00000110-01001100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za.d[w10, 1, vgx4]
+// CHECK-ENCODING: [0x30,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c30 <unknown>
+
+mova {z16.d - z19.d}, za.d[w10, 1] // 11000000-00000110-01001100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za.d[w10, 1, vgx4]
+// CHECK-ENCODING: [0x30,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c30 <unknown>
+
+mova {z28.d - z31.d}, za.d[w8, 6, vgx4] // 11000000-00000110-00001100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za.d[w8, 6, vgx4]
+// CHECK-ENCODING: [0xdc,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060cdc <unknown>
+
+mova {z28.d - z31.d}, za.d[w8, 6] // 11000000-00000110-00001100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za.d[w8, 6, vgx4]
+// CHECK-ENCODING: [0xdc,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060cdc <unknown>
+
+mova {z0.d - z3.d}, za.d[w11, 1, vgx4] // 11000000-00000110-01101100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w11, 1, vgx4]
+// CHECK-ENCODING: [0x20,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066c20 <unknown>
+
+mova {z0.d - z3.d}, za.d[w11, 1] // 11000000-00000110-01101100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w11, 1, vgx4]
+// CHECK-ENCODING: [0x20,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066c20 <unknown>
+
+mova {z4.d - z7.d}, za.d[w9, 4, vgx4] // 11000000-00000110-00101100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za.d[w9, 4, vgx4]
+// CHECK-ENCODING: [0x84,0x2c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062c84 <unknown>
+
+mova {z4.d - z7.d}, za.d[w9, 4] // 11000000-00000110-00101100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za.d[w9, 4, vgx4]
+// CHECK-ENCODING: [0x84,0x2c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062c84 <unknown>
+
+// Aliases
+
+mov {z0.d - z3.d}, za.d[w8, 0, vgx4] // 11000000-00000110-00001100-00000000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 0, vgx4]
+// CHECK-ENCODING: [0x00,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c00 <unknown>
+
+mov {z20.d - z23.d}, za.d[w10, 2, vgx4] // 11000000-00000110-01001100-01010100
+// CHECK-INST: mov { z20.d - z23.d }, za.d[w10, 2, vgx4]
+// CHECK-ENCODING: [0x54,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c54 <unknown>
+
+mov {z20.d - z23.d}, za.d[w11, 5, vgx4] // 11000000-00000110-01101100-10110100
+// CHECK-INST: mov { z20.d - z23.d }, za.d[w11, 5, vgx4]
+// CHECK-ENCODING: [0xb4,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066cb4 <unknown>
+
+mov {z28.d - z31.d}, za.d[w11, 7, vgx4] // 11000000-00000110-01101100-11111100
+// CHECK-INST: mov { z28.d - z31.d }, za.d[w11, 7, vgx4]
+// CHECK-ENCODING: [0xfc,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066cfc <unknown>
+
+mov {z4.d - z7.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100100
+// CHECK-INST: mov { z4.d - z7.d }, za.d[w8, 1, vgx4]
+// CHECK-ENCODING: [0x24,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c24 <unknown>
+
+mov {z0.d - z3.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 1, vgx4]
+// CHECK-ENCODING: [0x20,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c20 <unknown>
+
+mov {z24.d - z27.d}, za.d[w10, 3, vgx4] // 11000000-00000110-01001100-01111000
+// CHECK-INST: mov { z24.d - z27.d }, za.d[w10, 3, vgx4]
+// CHECK-ENCODING: [0x78,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c78 <unknown>
+
+mov {z0.d - z3.d}, za.d[w8, 4, vgx4] // 11000000-00000110-00001100-10000000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 4, vgx4]
+// CHECK-ENCODING: [0x80,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060c80 <unknown>
+
+mov {z16.d - z19.d}, za.d[w10, 1, vgx4] // 11000000-00000110-01001100-00110000
+// CHECK-INST: mov { z16.d - z19.d }, za.d[w10, 1, vgx4]
+// CHECK-ENCODING: [0x30,0x4c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064c30 <unknown>
+
+mov {z28.d - z31.d}, za.d[w8, 6, vgx4] // 11000000-00000110-00001100-11011100
+// CHECK-INST: mov { z28.d - z31.d }, za.d[w8, 6, vgx4]
+// CHECK-ENCODING: [0xdc,0x0c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060cdc <unknown>
+
+mov {z0.d - z3.d}, za.d[w11, 1, vgx4] // 11000000-00000110-01101100-00100000
+// CHECK-INST: mov { z0.d - z3.d }, za.d[w11, 1, vgx4]
+// CHECK-ENCODING: [0x20,0x6c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066c20 <unknown>
+
+mov {z4.d - z7.d}, za.d[w9, 4, vgx4] // 11000000-00000110-00101100-10000100
+// CHECK-INST: mov { z4.d - z7.d }, za.d[w9, 4, vgx4]
+// CHECK-ENCODING: [0x84,0x2c,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062c84 <unknown>
+
+
+mova za0h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000000
+// CHECK-INST: mov za0h.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x04,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40400 <unknown>
+
+mova za5h.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-01000101-00000101
+// CHECK-INST: mov za5h.d[w14, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0x45,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44505 <unknown>
+
+mova za7h.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-01100101-10000111
+// CHECK-INST: mov za7h.d[w15, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x65,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46587 <unknown>
+
+mova za7h.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-01100111-10000111
+// CHECK-INST: mov za7h.d[w15, 0:3], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0x67,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46787 <unknown>
+
+mova za5h.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-00000110-00000101
+// CHECK-INST: mov za5h.d[w12, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x06,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40605 <unknown>
+
+mova za1h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000001
+// CHECK-INST: mov za1h.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x04,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40401 <unknown>
+
+mova za0h.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-01000110-00000000
+// CHECK-INST: mov za0h.d[w14, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0x46,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44600 <unknown>
+
+mova za0h.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-00000101-10000000
+// CHECK-INST: mov za0h.d[w12, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x05,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40580 <unknown>
+
+mova za1h.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-01000100-00000001
+// CHECK-INST: mov za1h.d[w14, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x44,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44401 <unknown>
+
+mova za5h.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-00000110-10000101
+// CHECK-INST: mov za5h.d[w12, 0:3], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x06,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40685 <unknown>
+
+mova za2h.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-01100101-00000010
+// CHECK-INST: mov za2h.d[w15, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0x65,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46502 <unknown>
+
+mova za7h.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-00100101-10000111
+// CHECK-INST: mov za7h.d[w13, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x25,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c42587 <unknown>
+
+// Aliases
+
+mov za0h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000000
+// CHECK-INST: mov za0h.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x04,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40400 <unknown>
+
+mov za5h.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-01000101-00000101
+// CHECK-INST: mov za5h.d[w14, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0x45,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44505 <unknown>
+
+mov za7h.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-01100101-10000111
+// CHECK-INST: mov za7h.d[w15, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x65,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46587 <unknown>
+
+mov za7h.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-01100111-10000111
+// CHECK-INST: mov za7h.d[w15, 0:3], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0x67,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46787 <unknown>
+
+mov za5h.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-00000110-00000101
+// CHECK-INST: mov za5h.d[w12, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x06,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40605 <unknown>
+
+mov za1h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000001
+// CHECK-INST: mov za1h.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x04,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40401 <unknown>
+
+mov za0h.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-01000110-00000000
+// CHECK-INST: mov za0h.d[w14, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0x46,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44600 <unknown>
+
+mov za0h.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-00000101-10000000
+// CHECK-INST: mov za0h.d[w12, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x05,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40580 <unknown>
+
+mov za1h.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-01000100-00000001
+// CHECK-INST: mov za1h.d[w14, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x44,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c44401 <unknown>
+
+mov za5h.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-00000110-10000101
+// CHECK-INST: mov za5h.d[w12, 0:3], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x06,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c40685 <unknown>
+
+mov za2h.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-01100101-00000010
+// CHECK-INST: mov za2h.d[w15, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0x65,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c46502 <unknown>
+
+mov za7h.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-00100101-10000111
+// CHECK-INST: mov za7h.d[w13, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x25,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c42587 <unknown>
+
+
+mova za0v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000000
+// CHECK-INST: mov za0v.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x84,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48400 <unknown>
+
+mova za5v.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-11000101-00000101
+// CHECK-INST: mov za5v.d[w14, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0xc5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c505 <unknown>
+
+mova za7v.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-11100101-10000111
+// CHECK-INST: mov za7v.d[w15, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0xe5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e587 <unknown>
+
+mova za7v.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-11100111-10000111
+// CHECK-INST: mov za7v.d[w15, 0:3], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0xe7,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e787 <unknown>
+
+mova za5v.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-10000110-00000101
+// CHECK-INST: mov za5v.d[w12, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x86,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48605 <unknown>
+
+mova za1v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000001
+// CHECK-INST: mov za1v.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x84,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48401 <unknown>
+
+mova za0v.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-11000110-00000000
+// CHECK-INST: mov za0v.d[w14, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0xc6,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c600 <unknown>
+
+mova za0v.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-10000101-10000000
+// CHECK-INST: mov za0v.d[w12, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x85,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48580 <unknown>
+
+mova za1v.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-11000100-00000001
+// CHECK-INST: mov za1v.d[w14, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0xc4,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c401 <unknown>
+
+mova za5v.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-10000110-10000101
+// CHECK-INST: mov za5v.d[w12, 0:3], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x86,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48685 <unknown>
+
+mova za2v.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-11100101-00000010
+// CHECK-INST: mov za2v.d[w15, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0xe5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e502 <unknown>
+
+mova za7v.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-10100101-10000111
+// CHECK-INST: mov za7v.d[w13, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0xa5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4a587 <unknown>
+
+// Aliases
+
+mov za0v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000000
+// CHECK-INST: mov za0v.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x84,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48400 <unknown>
+
+mov za5v.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-11000101-00000101
+// CHECK-INST: mov za5v.d[w14, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0xc5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c505 <unknown>
+
+mov za7v.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-11100101-10000111
+// CHECK-INST: mov za7v.d[w15, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0xe5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e587 <unknown>
+
+mov za7v.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-11100111-10000111
+// CHECK-INST: mov za7v.d[w15, 0:3], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0xe7,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e787 <unknown>
+
+mov za5v.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-10000110-00000101
+// CHECK-INST: mov za5v.d[w12, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x86,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48605 <unknown>
+
+mov za1v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000001
+// CHECK-INST: mov za1v.d[w12, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x84,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48401 <unknown>
+
+mov za0v.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-11000110-00000000
+// CHECK-INST: mov za0v.d[w14, 0:3], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0xc6,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c600 <unknown>
+
+mov za0v.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-10000101-10000000
+// CHECK-INST: mov za0v.d[w12, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x85,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48580 <unknown>
+
+mov za1v.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-11000100-00000001
+// CHECK-INST: mov za1v.d[w14, 0:3], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0xc4,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4c401 <unknown>
+
+mov za5v.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-10000110-10000101
+// CHECK-INST: mov za5v.d[w12, 0:3], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x86,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c48685 <unknown>
+
+mov za2v.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-11100101-00000010
+// CHECK-INST: mov za2v.d[w15, 0:3], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0xe5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4e502 <unknown>
+
+mov za7v.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-10100101-10000111
+// CHECK-INST: mov za7v.d[w13, 0:3], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0xa5,0xc4,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0c4a587 <unknown>
+
+
+mova za.d[w8, 0, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000000
+// CHECK-INST: mov za.d[w8, 0, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x0c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040c00 <unknown>
+
+mova za.d[w8, 0], {z0.d - z3.d} // 11000000-00000100-00001100-00000000
+// CHECK-INST: mov za.d[w8, 0, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x0c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040c00 <unknown>
+
+mova za.d[w10, 5, vgx4], {z8.d - z11.d} // 11000000-00000100-01001101-00000101
+// CHECK-INST: mov za.d[w10, 5, vgx4], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0x4d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044d05 <unknown>
+
+mova za.d[w10, 5], {z8.d - z11.d} // 11000000-00000100-01001101-00000101
+// CHECK-INST: mov za.d[w10, 5, vgx4], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0x4d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044d05 <unknown>
+
+mova za.d[w11, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-01101101-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x6d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046d87 <unknown>
+
+mova za.d[w11, 7], {z12.d - z15.d} // 11000000-00000100-01101101-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x6d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046d87 <unknown>
+
+mova za.d[w11, 7, vgx4], {z28.d - z31.d} // 11000000-00000100-01101111-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx4], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0x6f,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046f87 <unknown>
+
+mova za.d[w11, 7], {z28.d - z31.d} // 11000000-00000100-01101111-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx4], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0x6f,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046f87 <unknown>
+
+mova za.d[w8, 5, vgx4], {z16.d - z19.d} // 11000000-00000100-00001110-00000101
+// CHECK-INST: mov za.d[w8, 5, vgx4], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x0e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040e05 <unknown>
+
+mova za.d[w8, 5], {z16.d - z19.d} // 11000000-00000100-00001110-00000101
+// CHECK-INST: mov za.d[w8, 5, vgx4], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x0e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040e05 <unknown>
+
+mova za.d[w8, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000001
+// CHECK-INST: mov za.d[w8, 1, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x0c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040c01 <unknown>
+
+mova za.d[w8, 1], {z0.d - z3.d} // 11000000-00000100-00001100-00000001
+// CHECK-INST: mov za.d[w8, 1, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x0c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040c01 <unknown>
+
+mova za.d[w10, 0, vgx4], {z16.d - z19.d} // 11000000-00000100-01001110-00000000
+// CHECK-INST: mov za.d[w10, 0, vgx4], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0x4e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044e00 <unknown>
+
+mova za.d[w10, 0], {z16.d - z19.d} // 11000000-00000100-01001110-00000000
+// CHECK-INST: mov za.d[w10, 0, vgx4], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0x4e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044e00 <unknown>
+
+mova za.d[w8, 0, vgx4], {z12.d - z15.d} // 11000000-00000100-00001101-10000000
+// CHECK-INST: mov za.d[w8, 0, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x0d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040d80 <unknown>
+
+mova za.d[w8, 0], {z12.d - z15.d} // 11000000-00000100-00001101-10000000
+// CHECK-INST: mov za.d[w8, 0, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x0d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040d80 <unknown>
+
+mova za.d[w10, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-01001100-00000001
+// CHECK-INST: mov za.d[w10, 1, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x4c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044c01 <unknown>
+
+mova za.d[w10, 1], {z0.d - z3.d} // 11000000-00000100-01001100-00000001
+// CHECK-INST: mov za.d[w10, 1, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x4c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044c01 <unknown>
+
+mova za.d[w8, 5, vgx4], {z20.d - z23.d} // 11000000-00000100-00001110-10000101
+// CHECK-INST: mov za.d[w8, 5, vgx4], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x0e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040e85 <unknown>
+
+mova za.d[w8, 5], {z20.d - z23.d} // 11000000-00000100-00001110-10000101
+// CHECK-INST: mov za.d[w8, 5, vgx4], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x0e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040e85 <unknown>
+
+mova za.d[w11, 2, vgx4], {z8.d - z11.d} // 11000000-00000100-01101101-00000010
+// CHECK-INST: mov za.d[w11, 2, vgx4], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0x6d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046d02 <unknown>
+
+mova za.d[w11, 2], {z8.d - z11.d} // 11000000-00000100-01101101-00000010
+// CHECK-INST: mov za.d[w11, 2, vgx4], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0x6d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046d02 <unknown>
+
+mova za.d[w9, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-00101101-10000111
+// CHECK-INST: mov za.d[w9, 7, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x2d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042d87 <unknown>
+
+mova za.d[w9, 7], {z12.d - z15.d} // 11000000-00000100-00101101-10000111
+// CHECK-INST: mov za.d[w9, 7, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x2d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042d87 <unknown>
+
+// Aliases
+
+mov za.d[w8, 0, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000000
+// CHECK-INST: mov za.d[w8, 0, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x00,0x0c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040c00 <unknown>
+
+mov za.d[w10, 5, vgx4], {z8.d - z11.d} // 11000000-00000100-01001101-00000101
+// CHECK-INST: mov za.d[w10, 5, vgx4], { z8.d - z11.d }
+// CHECK-ENCODING: [0x05,0x4d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044d05 <unknown>
+
+mov za.d[w11, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-01101101-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x6d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046d87 <unknown>
+
+mov za.d[w11, 7, vgx4], {z28.d - z31.d} // 11000000-00000100-01101111-10000111
+// CHECK-INST: mov za.d[w11, 7, vgx4], { z28.d - z31.d }
+// CHECK-ENCODING: [0x87,0x6f,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046f87 <unknown>
+
+mov za.d[w8, 5, vgx4], {z16.d - z19.d} // 11000000-00000100-00001110-00000101
+// CHECK-INST: mov za.d[w8, 5, vgx4], { z16.d - z19.d }
+// CHECK-ENCODING: [0x05,0x0e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040e05 <unknown>
+
+mov za.d[w8, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000001
+// CHECK-INST: mov za.d[w8, 1, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x0c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040c01 <unknown>
+
+mov za.d[w10, 0, vgx4], {z16.d - z19.d} // 11000000-00000100-01001110-00000000
+// CHECK-INST: mov za.d[w10, 0, vgx4], { z16.d - z19.d }
+// CHECK-ENCODING: [0x00,0x4e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044e00 <unknown>
+
+mov za.d[w8, 0, vgx4], {z12.d - z15.d} // 11000000-00000100-00001101-10000000
+// CHECK-INST: mov za.d[w8, 0, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x80,0x0d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040d80 <unknown>
+
+mov za.d[w10, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-01001100-00000001
+// CHECK-INST: mov za.d[w10, 1, vgx4], { z0.d - z3.d }
+// CHECK-ENCODING: [0x01,0x4c,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044c01 <unknown>
+
+mov za.d[w8, 5, vgx4], {z20.d - z23.d} // 11000000-00000100-00001110-10000101
+// CHECK-INST: mov za.d[w8, 5, vgx4], { z20.d - z23.d }
+// CHECK-ENCODING: [0x85,0x0e,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040e85 <unknown>
+
+mov za.d[w11, 2, vgx4], {z8.d - z11.d} // 11000000-00000100-01101101-00000010
+// CHECK-INST: mov za.d[w11, 2, vgx4], { z8.d - z11.d }
+// CHECK-ENCODING: [0x02,0x6d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046d02 <unknown>
+
+mov za.d[w9, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-00101101-10000111
+// CHECK-INST: mov za.d[w9, 7, vgx4], { z12.d - z15.d }
+// CHECK-ENCODING: [0x87,0x2d,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042d87 <unknown>
+
+
+mova {z0.b - z3.b}, za0h.b[w12, 0:3] // 11000000-00000110-00000100-00000000
+// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060400 <unknown>
+
+mova {z20.b - z23.b}, za0h.b[w14, 8:11] // 11000000-00000110-01000100-01010100
+// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w14, 8:11]
+// CHECK-ENCODING: [0x54,0x44,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064454 <unknown>
+
+mova {z20.b - z23.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00110100
+// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w15, 4:7]
+// CHECK-ENCODING: [0x34,0x64,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066434 <unknown>
+
+mova {z28.b - z31.b}, za0h.b[w15, 12:15] // 11000000-00000110-01100100-01111100
+// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w15, 12:15]
+// CHECK-ENCODING: [0x7c,0x64,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006647c <unknown>
+
+mova {z4.b - z7.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100100
+// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060424 <unknown>
+
+mova {z0.b - z3.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060420 <unknown>
+
+mova {z24.b - z27.b}, za0h.b[w14, 12:15] // 11000000-00000110-01000100-01111000
+// CHECK-INST: mov { z24.b - z27.b }, za0h.b[w14, 12:15]
+// CHECK-ENCODING: [0x78,0x44,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064478 <unknown>
+
+mova {z16.b - z19.b}, za0h.b[w14, 4:7] // 11000000-00000110-01000100-00110000
+// CHECK-INST: mov { z16.b - z19.b }, za0h.b[w14, 4:7]
+// CHECK-ENCODING: [0x30,0x44,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064430 <unknown>
+
+mova {z28.b - z31.b}, za0h.b[w12, 8:11] // 11000000-00000110-00000100-01011100
+// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w12, 8:11]
+// CHECK-ENCODING: [0x5c,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006045c <unknown>
+
+mova {z0.b - z3.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w15, 4:7]
+// CHECK-ENCODING: [0x20,0x64,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066420 <unknown>
+
+mova {z4.b - z7.b}, za0h.b[w13, 0:3] // 11000000-00000110-00100100-00000100
+// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w13, 0:3]
+// CHECK-ENCODING: [0x04,0x24,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062404 <unknown>
+
+// Aliases
+
+mov {z0.b - z3.b}, za0h.b[w12, 0:3] // 11000000-00000110-00000100-00000000
+// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060400 <unknown>
+
+mov {z20.b - z23.b}, za0h.b[w14, 8:11] // 11000000-00000110-01000100-01010100
+// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w14, 8:11]
+// CHECK-ENCODING: [0x54,0x44,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064454 <unknown>
+
+mov {z20.b - z23.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00110100
+// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w15, 4:7]
+// CHECK-ENCODING: [0x34,0x64,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066434 <unknown>
+
+mov {z28.b - z31.b}, za0h.b[w15, 12:15] // 11000000-00000110-01100100-01111100
+// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w15, 12:15]
+// CHECK-ENCODING: [0x7c,0x64,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006647c <unknown>
+
+mov {z4.b - z7.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100100
+// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060424 <unknown>
+
+mov {z0.b - z3.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0060420 <unknown>
+
+mov {z24.b - z27.b}, za0h.b[w14, 12:15] // 11000000-00000110-01000100-01111000
+// CHECK-INST: mov { z24.b - z27.b }, za0h.b[w14, 12:15]
+// CHECK-ENCODING: [0x78,0x44,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064478 <unknown>
+
+mov {z16.b - z19.b}, za0h.b[w14, 4:7] // 11000000-00000110-01000100-00110000
+// CHECK-INST: mov { z16.b - z19.b }, za0h.b[w14, 4:7]
+// CHECK-ENCODING: [0x30,0x44,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0064430 <unknown>
+
+mov {z28.b - z31.b}, za0h.b[w12, 8:11] // 11000000-00000110-00000100-01011100
+// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w12, 8:11]
+// CHECK-ENCODING: [0x5c,0x04,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006045c <unknown>
+
+mov {z0.b - z3.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w15, 4:7]
+// CHECK-ENCODING: [0x20,0x64,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0066420 <unknown>
+
+mov {z4.b - z7.b}, za0h.b[w13, 0:3] // 11000000-00000110-00100100-00000100
+// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w13, 0:3]
+// CHECK-ENCODING: [0x04,0x24,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0062404 <unknown>
+
+
+mova {z0.b - z3.b}, za0v.b[w12, 0:3] // 11000000-00000110-10000100-00000000
+// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068400 <unknown>
+
+mova {z20.b - z23.b}, za0v.b[w14, 8:11] // 11000000-00000110-11000100-01010100
+// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w14, 8:11]
+// CHECK-ENCODING: [0x54,0xc4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c454 <unknown>
+
+mova {z20.b - z23.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00110100
+// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w15, 4:7]
+// CHECK-ENCODING: [0x34,0xe4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e434 <unknown>
+
+mova {z28.b - z31.b}, za0v.b[w15, 12:15] // 11000000-00000110-11100100-01111100
+// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w15, 12:15]
+// CHECK-ENCODING: [0x7c,0xe4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e47c <unknown>
+
+mova {z4.b - z7.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100100
+// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068424 <unknown>
+
+mova {z0.b - z3.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068420 <unknown>
+
+mova {z24.b - z27.b}, za0v.b[w14, 12:15] // 11000000-00000110-11000100-01111000
+// CHECK-INST: mov { z24.b - z27.b }, za0v.b[w14, 12:15]
+// CHECK-ENCODING: [0x78,0xc4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c478 <unknown>
+
+mova {z16.b - z19.b}, za0v.b[w14, 4:7] // 11000000-00000110-11000100-00110000
+// CHECK-INST: mov { z16.b - z19.b }, za0v.b[w14, 4:7]
+// CHECK-ENCODING: [0x30,0xc4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c430 <unknown>
+
+mova {z28.b - z31.b}, za0v.b[w12, 8:11] // 11000000-00000110-10000100-01011100
+// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w12, 8:11]
+// CHECK-ENCODING: [0x5c,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006845c <unknown>
+
+mova {z0.b - z3.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w15, 4:7]
+// CHECK-ENCODING: [0x20,0xe4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e420 <unknown>
+
+mova {z4.b - z7.b}, za0v.b[w13, 0:3] // 11000000-00000110-10100100-00000100
+// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w13, 0:3]
+// CHECK-ENCODING: [0x04,0xa4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006a404 <unknown>
+
+// Aliases
+
+mov {z0.b - z3.b}, za0v.b[w12, 0:3] // 11000000-00000110-10000100-00000000
+// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 0:3]
+// CHECK-ENCODING: [0x00,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068400 <unknown>
+
+mov {z20.b - z23.b}, za0v.b[w14, 8:11] // 11000000-00000110-11000100-01010100
+// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w14, 8:11]
+// CHECK-ENCODING: [0x54,0xc4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c454 <unknown>
+
+mov {z20.b - z23.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00110100
+// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w15, 4:7]
+// CHECK-ENCODING: [0x34,0xe4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e434 <unknown>
+
+mov {z28.b - z31.b}, za0v.b[w15, 12:15] // 11000000-00000110-11100100-01111100
+// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w15, 12:15]
+// CHECK-ENCODING: [0x7c,0xe4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e47c <unknown>
+
+mov {z4.b - z7.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100100
+// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w12, 4:7]
+// CHECK-ENCODING: [0x24,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068424 <unknown>
+
+mov {z0.b - z3.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 4:7]
+// CHECK-ENCODING: [0x20,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0068420 <unknown>
+
+mov {z24.b - z27.b}, za0v.b[w14, 12:15] // 11000000-00000110-11000100-01111000
+// CHECK-INST: mov { z24.b - z27.b }, za0v.b[w14, 12:15]
+// CHECK-ENCODING: [0x78,0xc4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c478 <unknown>
+
+mov {z16.b - z19.b}, za0v.b[w14, 4:7] // 11000000-00000110-11000100-00110000
+// CHECK-INST: mov { z16.b - z19.b }, za0v.b[w14, 4:7]
+// CHECK-ENCODING: [0x30,0xc4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006c430 <unknown>
+
+mov {z28.b - z31.b}, za0v.b[w12, 8:11] // 11000000-00000110-10000100-01011100
+// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w12, 8:11]
+// CHECK-ENCODING: [0x5c,0x84,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006845c <unknown>
+
+mov {z0.b - z3.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00100000
+// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w15, 4:7]
+// CHECK-ENCODING: [0x20,0xe4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006e420 <unknown>
+
+mov {z4.b - z7.b}, za0v.b[w13, 0:3] // 11000000-00000110-10100100-00000100
+// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w13, 0:3]
+// CHECK-ENCODING: [0x04,0xa4,0x06,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c006a404 <unknown>
+
+
+mova za0h.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-00000100-00000000
+// CHECK-INST: mov za0h.b[w12, 0:3], { z0.b - z3.b }
+// CHECK-ENCODING: [0x00,0x04,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040400 <unknown>
+
+mova za0h.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-01000101-00000001
+// CHECK-INST: mov za0h.b[w14, 4:7], { z8.b - z11.b }
+// CHECK-ENCODING: [0x01,0x45,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044501 <unknown>
+
+mova za0h.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-01100101-10000011
+// CHECK-INST: mov za0h.b[w15, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0x65,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046583 <unknown>
+
+mova za0h.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-01100111-10000011
+// CHECK-INST: mov za0h.b[w15, 12:15], { z28.b - z31.b }
+// CHECK-ENCODING: [0x83,0x67,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046783 <unknown>
+
+mova za0h.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-00000110-00000001
+// CHECK-INST: mov za0h.b[w12, 4:7], { z16.b - z19.b }
+// CHECK-ENCODING: [0x01,0x06,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040601 <unknown>
+
+mova za0h.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-00000100-00000001
+// CHECK-INST: mov za0h.b[w12, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0x04,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040401 <unknown>
+
+mova za0h.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-01000110-00000000
+// CHECK-INST: mov za0h.b[w14, 0:3], { z16.b - z19.b }
+// CHECK-ENCODING: [0x00,0x46,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044600 <unknown>
+
+mova za0h.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-00000101-10000000
+// CHECK-INST: mov za0h.b[w12, 0:3], { z12.b - z15.b }
+// CHECK-ENCODING: [0x80,0x05,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040580 <unknown>
+
+mova za0h.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-01000100-00000001
+// CHECK-INST: mov za0h.b[w14, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0x44,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044401 <unknown>
+
+mova za0h.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-00000110-10000001
+// CHECK-INST: mov za0h.b[w12, 4:7], { z20.b - z23.b }
+// CHECK-ENCODING: [0x81,0x06,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040681 <unknown>
+
+mova za0h.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-01100101-00000010
+// CHECK-INST: mov za0h.b[w15, 8:11], { z8.b - z11.b }
+// CHECK-ENCODING: [0x02,0x65,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046502 <unknown>
+
+mova za0h.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-00100101-10000011
+// CHECK-INST: mov za0h.b[w13, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0x25,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042583 <unknown>
+
+// Aliases
+
+mov za0h.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-00000100-00000000
+// CHECK-INST: mov za0h.b[w12, 0:3], { z0.b - z3.b }
+// CHECK-ENCODING: [0x00,0x04,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040400 <unknown>
+
+mov za0h.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-01000101-00000001
+// CHECK-INST: mov za0h.b[w14, 4:7], { z8.b - z11.b }
+// CHECK-ENCODING: [0x01,0x45,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044501 <unknown>
+
+mov za0h.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-01100101-10000011
+// CHECK-INST: mov za0h.b[w15, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0x65,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046583 <unknown>
+
+mov za0h.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-01100111-10000011
+// CHECK-INST: mov za0h.b[w15, 12:15], { z28.b - z31.b }
+// CHECK-ENCODING: [0x83,0x67,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046783 <unknown>
+
+mov za0h.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-00000110-00000001
+// CHECK-INST: mov za0h.b[w12, 4:7], { z16.b - z19.b }
+// CHECK-ENCODING: [0x01,0x06,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040601 <unknown>
+
+mov za0h.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-00000100-00000001
+// CHECK-INST: mov za0h.b[w12, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0x04,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040401 <unknown>
+
+mov za0h.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-01000110-00000000
+// CHECK-INST: mov za0h.b[w14, 0:3], { z16.b - z19.b }
+// CHECK-ENCODING: [0x00,0x46,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044600 <unknown>
+
+mov za0h.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-00000101-10000000
+// CHECK-INST: mov za0h.b[w12, 0:3], { z12.b - z15.b }
+// CHECK-ENCODING: [0x80,0x05,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040580 <unknown>
+
+mov za0h.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-01000100-00000001
+// CHECK-INST: mov za0h.b[w14, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0x44,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0044401 <unknown>
+
+mov za0h.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-00000110-10000001
+// CHECK-INST: mov za0h.b[w12, 4:7], { z20.b - z23.b }
+// CHECK-ENCODING: [0x81,0x06,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0040681 <unknown>
+
+mov za0h.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-01100101-00000010
+// CHECK-INST: mov za0h.b[w15, 8:11], { z8.b - z11.b }
+// CHECK-ENCODING: [0x02,0x65,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0046502 <unknown>
+
+mov za0h.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-00100101-10000011
+// CHECK-INST: mov za0h.b[w13, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0x25,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0042583 <unknown>
+
+
+mova za0v.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-10000100-00000000
+// CHECK-INST: mov za0v.b[w12, 0:3], { z0.b - z3.b }
+// CHECK-ENCODING: [0x00,0x84,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048400 <unknown>
+
+mova za0v.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-11000101-00000001
+// CHECK-INST: mov za0v.b[w14, 4:7], { z8.b - z11.b }
+// CHECK-ENCODING: [0x01,0xc5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c501 <unknown>
+
+mova za0v.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-11100101-10000011
+// CHECK-INST: mov za0v.b[w15, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0xe5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e583 <unknown>
+
+mova za0v.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-11100111-10000011
+// CHECK-INST: mov za0v.b[w15, 12:15], { z28.b - z31.b }
+// CHECK-ENCODING: [0x83,0xe7,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e783 <unknown>
+
+mova za0v.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-10000110-00000001
+// CHECK-INST: mov za0v.b[w12, 4:7], { z16.b - z19.b }
+// CHECK-ENCODING: [0x01,0x86,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048601 <unknown>
+
+mova za0v.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-10000100-00000001
+// CHECK-INST: mov za0v.b[w12, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0x84,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048401 <unknown>
+
+mova za0v.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-11000110-00000000
+// CHECK-INST: mov za0v.b[w14, 0:3], { z16.b - z19.b }
+// CHECK-ENCODING: [0x00,0xc6,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c600 <unknown>
+
+mova za0v.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-10000101-10000000
+// CHECK-INST: mov za0v.b[w12, 0:3], { z12.b - z15.b }
+// CHECK-ENCODING: [0x80,0x85,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048580 <unknown>
+
+mova za0v.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-11000100-00000001
+// CHECK-INST: mov za0v.b[w14, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0xc4,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c401 <unknown>
+
+mova za0v.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-10000110-10000001
+// CHECK-INST: mov za0v.b[w12, 4:7], { z20.b - z23.b }
+// CHECK-ENCODING: [0x81,0x86,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048681 <unknown>
+
+mova za0v.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-11100101-00000010
+// CHECK-INST: mov za0v.b[w15, 8:11], { z8.b - z11.b }
+// CHECK-ENCODING: [0x02,0xe5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e502 <unknown>
+
+mova za0v.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-10100101-10000011
+// CHECK-INST: mov za0v.b[w13, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0xa5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004a583 <unknown>
+
+// Aliases
+
+mov za0v.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-10000100-00000000
+// CHECK-INST: mov za0v.b[w12, 0:3], { z0.b - z3.b }
+// CHECK-ENCODING: [0x00,0x84,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048400 <unknown>
+
+mov za0v.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-11000101-00000001
+// CHECK-INST: mov za0v.b[w14, 4:7], { z8.b - z11.b }
+// CHECK-ENCODING: [0x01,0xc5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c501 <unknown>
+
+mov za0v.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-11100101-10000011
+// CHECK-INST: mov za0v.b[w15, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0xe5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e583 <unknown>
+
+mov za0v.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-11100111-10000011
+// CHECK-INST: mov za0v.b[w15, 12:15], { z28.b - z31.b }
+// CHECK-ENCODING: [0x83,0xe7,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e783 <unknown>
+
+mov za0v.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-10000110-00000001
+// CHECK-INST: mov za0v.b[w12, 4:7], { z16.b - z19.b }
+// CHECK-ENCODING: [0x01,0x86,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048601 <unknown>
+
+mov za0v.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-10000100-00000001
+// CHECK-INST: mov za0v.b[w12, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0x84,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048401 <unknown>
+
+mov za0v.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-11000110-00000000
+// CHECK-INST: mov za0v.b[w14, 0:3], { z16.b - z19.b }
+// CHECK-ENCODING: [0x00,0xc6,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c600 <unknown>
+
+mov za0v.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-10000101-10000000
+// CHECK-INST: mov za0v.b[w12, 0:3], { z12.b - z15.b }
+// CHECK-ENCODING: [0x80,0x85,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048580 <unknown>
+
+mov za0v.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-11000100-00000001
+// CHECK-INST: mov za0v.b[w14, 4:7], { z0.b - z3.b }
+// CHECK-ENCODING: [0x01,0xc4,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004c401 <unknown>
+
+mov za0v.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-10000110-10000001
+// CHECK-INST: mov za0v.b[w12, 4:7], { z20.b - z23.b }
+// CHECK-ENCODING: [0x81,0x86,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c0048681 <unknown>
+
+mov za0v.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-11100101-00000010
+// CHECK-INST: mov za0v.b[w15, 8:11], { z8.b - z11.b }
+// CHECK-ENCODING: [0x02,0xe5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004e502 <unknown>
+
+mov za0v.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-10100101-10000011
+// CHECK-INST: mov za0v.b[w13, 12:15], { z12.b - z15.b }
+// CHECK-ENCODING: [0x83,0xa5,0x04,0xc0]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c004a583 <unknown>
+
More information about the llvm-commits
mailing list