[AArch64]SME2 MOV Instructions

[CarolineConcatto]

Summary

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

[CarolineConcatto]

Rebase

[CarolineConcatto]

• Rebase

[paulwalker-arm]

llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td

434–437

Should these not be MOVA/MOV? the register suffix points to the direction of travel.

436

mova?

llvm/lib/Target/AArch64/SMEInstrFormats.td

2246

Please add comments to all the base instruction classes that reference their encoding groups.

2269

To be honest I don't see any value to this class, especially as it only contains a single InstAlias. I think the aliases will be more readable if just emitted directly.

2437

The vg2 case didn't do this so it's fine but for sme2_mova_vec_to_tile_vg4_multi_base please can you pass in the 3-bit opc and then use the {0, ?, ?} trick.

2553

Can sme2_mova_vec_to_array_vg24_multi take a 5-bit opcode and use { 0, ?,.. and then the vg4 instance will be {1, ?, ?, ?, 0 }

2887

Same comment as with sme2_mova_vec_to_tile_vg4_multi_base.

3000

Same comment as with sme2_mova_vec_to_array_vg2_multi.

[CarolineConcatto]

• Address review comments

[CarolineConcatto]

llvm/lib/Target/AArch64/SMEInstrFormats.td

2269

We created precendent for that when we created for sme1
multiclass sme_vector_to_tile_aliases<

I try to remove the alias class, but one class like this:

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">;

Would become 2, one for Horizontal and another for Vertical:

def : InstAlias<mnemonic # "\t$ZAd[$Rs, $imm], $Zn",
                (!cast<Instruction>(NAME # _B) TileVector8H:$ZAd, rv_ty:$Rs, index_ty:$imm, ZZ_b_mul_r:$Zn), 1>;
def : InstAlias<mnemonic # "\t$ZAd[$Rs, $imm], $Zn",
                (!cast<Instruction>(NAME # _B) TileVector8V:$ZAd, rv_ty:$Rs, index_ty:$imm, ZZ_b_mul_r:$Zn), 1>;

We will have to duplicate the number of alias.
And I cannot pass the types (TileVector8H/TileVector8V, TileVector16H/TileVector16V/...)in the previous class :

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>;
}

Because it depends on the size.

Unless you know some tricks in tablegen to solve that problem.

[paulwalker-arm]

A couple of suggestions but otherwise looks good. I think my op3:op4:op5 comment will help with your follow-on work but I'm also happy if you want to delay that until you need the support (i.e. when you add MOVAZ).

llvm/lib/Target/AArch64/AArch64InstrFormats.td

1396

immediate

llvm/lib/Target/AArch64/SMEInstrFormats.td

2269

I see, thanks for explaining. Perhaps the H/V hierarchy is upside down but given this matches the precedent let's stick with what you've got.

2823

Please can this be Inst{7-5} = op;? then pass in {0, ?, ?} and {?, ?, ?} accordingly.

2883

indent me

2908

indent me

2935

I'm being picky but I think the following better matches the documentation. However, I understand this might be excessively verbose so it's up to you which you prefer.

let Inst{31-15} = 0b11000000;
let Inst{23-22} = 0b00; //op0
let Inst{21-19} = 0b000;
let Inst{18} = 0b1; // op1
let Inst{17} = 0b1;
let Inst{16-15} = 0b00; // op2

Same goes for sme2_mova_vec_to_array_vg24_multi.

2939

It'll better reflect the encoding group if you make op3:op4:op5 be the passed in opcode. I know there's commonality across some of the bits but it makes it easier to match the documentation and it'll just work when you come to add MOVAZ.

llvm/lib/Target/AArch64/AArch64InstrFormats.td

 class UImmScaledMemoryIndexedRange<int Width, int Scale, int OffsetVal> : AsmOperandClass {
   let Name = "UImm" # Width # "s" # Scale # "Range";
   let DiagnosticType = "InvalidMemoryIndexedRange" # Scale # "UImm" # Width;
   let RenderMethod = "addImmScaledRangeOperands<" # Scale # ">";
   let PredicateMethod = "isUImmScaled<" # Width # ", " # Scale # ", " # OffsetVal # ", /*IsRange=*/true>";
   let ParserMethod = "tryParseImmRange";
 }
 
+// Implicit immediates 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 UImm2s4RangeOperand : UImmScaledMemoryIndexedRange<2, 4, 3>;
 def UImm2s2RangeOperand : UImmScaledMemoryIndexedRange<2, 2, 1>;
 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 uimm2s4range : Operand<i64>, ImmLeaf<i64,
 [{ return Imm >= 0 && Imm <= 12 && ((Imm % 4) == 0); }], UImmS4XForm> {
   let PrintMethod = "printImmRangeScale<4, 3>";
   let ParserMatchClass = UImm2s4RangeOperand;
 }
 
 def uimm1s4range : Operand<i64>, ImmLeaf<i64,
 [{ return Imm >= 0 && Imm <= 4 && ((Imm % 4) == 0); }], UImmS4XForm> {

llvm/lib/Target/AArch64/AArch64RegisterInfo.td

 
 class MatrixOperand<RegisterClass RC, int EltSize> : RegisterOperand<RC> {
   let ParserMatchClass = MatrixAsmOperand<!cast<string>(RC), EltSize>;
   let PrintMethod = "printMatrix<" # EltSize # ">";
 }
 
 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>;
 
 class MatrixTileListAsmOperand : AsmOperandClass {
   let Name = "MatrixTileList";
   let ParserMethod = "tryParseMatrixTileList";
   let RenderMethod = "addMatrixTileListOperands";
   let PredicateMethod = "isMatrixTileList";

llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td

 defm UUNPK_VG2_2ZZ  : sme2_unpk_vector_vg2<"uunpk", 0b1>;
 defm UUNPK_VG4_4Z2Z : sme2_unpk_vector_vg4<"uunpk", 0b1>;
 
 defm ZIP_VG2_2ZZZ : sme2_zip_vector_vg2<"zip", 0b0>;
 defm UZP_VG2_2ZZZ : sme2_zip_vector_vg2<"uzp", 0b1>;
 defm ZIP_VG4_4Z4Z : sme2_zip_vector_vg4<"zip", 0b0>;
 defm UZP_VG4_4Z4Z : sme2_zip_vector_vg4<"uzp", 0b1>;
 
+defm INSERT_TI2Z  : sme2_mova_vec_to_tile_vg2_multi<"mova">;
+defm INSERT_TI4Z  : sme2_mova_vec_to_tile_vg4_multi<"mova">;
+defm EXTRACT_2ZTI : sme2_mova_tile_to_vec_vg2_multi<"mov">;
+defm EXTRACT_4ZTI : sme2_mova_tile_to_vec_vg4_multi<"mov">;
+
+defm INSERT_VG2_2ZMI : sme2_mova_vec_to_array_vg2_multi<"mova">;
+defm INSERT_VG4_4ZMI : sme2_mova_vec_to_array_vg4_multi<"mova">;
+defm EXTRACT_VG2_2ZMI : sme2_mova_array_to_vec_vg2_multi<"mova">;
+defm EXTRACT_VG4_4ZMI : sme2_mova_array_to_vec_vg4_multi<"mova">;
+
 }
 
 
 let Predicates = [HasSME2, HasSMEI64] in {
 defm ADD_VG2_M2ZZ_D  : sme2_mla_add_sub_array_vg2_single_D<"add", 0b10>;
 defm ADD_VG4_M4ZZ_D  : sme2_mla_add_sub_array_vg4_single_D<"add", 0b10>;
 defm ADD_VG2_M2Z2Z_D : sme2_mla_add_sub_array_vg2_multi_D<"add", 0b10>;
 defm ADD_VG4_M4Z4Z_D : sme2_mla_add_sub_array_vg4_multi_D<"add", 0b10>;

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

AArch64AsmParser::tryParseImmWithOptionalShift(OperandVector &Operands) {
   else if (getTok().isNot(AsmToken::Comma)) {
     Operands.push_back(
         AArch64Operand::CreateImm(Imm, S, getLoc(), getContext()));
     return MatchOperand_Success;
   }
 
   // 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) ||
       !getTok().getIdentifier().equals_insensitive("lsl")) {
     Error(getLoc(), "only 'lsl #+N' valid after immediate");
     return MatchOperand_ParseFail;
   }
 
case Match_InvalidImm1_16:
     return Error(Loc, "immediate must be an integer in range [1, 16].");
   case Match_InvalidImm1_32:
     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].");
     // For SME2
   case Match_InvalidMemoryIndexed8UImm3:
     return Error(Loc, "index must be a multiple of 8 in range [0, 56].");
+  case Match_InvalidMemoryIndexedRange2UImm0:
+    return Error(Loc, "vector select offset must be the immediate range 0: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(
         Loc,
         "vector select offset must be an immediate range of the form "
         "<immf>:<imml>, "
         "where the first immediate is a multiple of 4 in the range [0, 4] or "
         "[0, 12] "
         "depending on the instruction, and the second immediate is immf + 3.");
+  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(
         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, 6] or "
         "[0, 14] "
case Match_InvalidMatrixTileVectorV128:
     return Error(Loc,
                  "invalid matrix operand, expected za[0-15]h.q or za[0-15]v.q");
   case Match_InvalidMatrixTile32:
     return Error(Loc, "invalid matrix operand, expected za[0-3].s");
   case Match_InvalidMatrixTile64:
     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:
     return Error(Loc, "invalid matrix operand, expected suffix .d");
   case Match_InvalidMatrixIndexGPR32_12_15:
     return Error(Loc, "operand must be a register in range [w12, w15]");
   case Match_InvalidSVEVectorListMul2x8:
   case Match_InvalidSVEVectorListMul2x16:
bool AArch64AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
   case Match_InvalidImm0_127:
   case Match_InvalidImm0_255:
   case Match_InvalidImm0_65535:
   case Match_InvalidImm1_8:
   case Match_InvalidImm1_16:
   case Match_InvalidImm1_32:
   case Match_InvalidImm1_64:
   case Match_InvalidMemoryIndexed8UImm3:
+  case Match_InvalidMemoryIndexedRange2UImm0:
+  case Match_InvalidMemoryIndexedRange4UImm0:
   case Match_InvalidMemoryIndexedRange4UImm1:
   case Match_InvalidMemoryIndexedRange4UImm2:
+  case Match_InvalidMemoryIndexedRange2UImm1:
   case Match_InvalidMemoryIndexedRange2UImm2:
   case Match_InvalidMemoryIndexedRange2UImm3:
   case Match_InvalidSVEAddSubImm8:
   case Match_InvalidSVEAddSubImm16:
   case Match_InvalidSVEAddSubImm32:
   case Match_InvalidSVEAddSubImm64:
   case Match_InvalidSVECpyImm8:
   case Match_InvalidSVECpyImm16:
bool AArch64AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
   case Match_InvalidSVEPredicateDReg:
   case Match_InvalidSVEPredicate3bAnyReg:
   case Match_InvalidSVEExactFPImmOperandHalfOne:
   case Match_InvalidSVEExactFPImmOperandHalfTwo:
   case Match_InvalidSVEExactFPImmOperandZeroOne:
   case Match_InvalidMatrixTile32:
   case Match_InvalidMatrixTile64:
   case Match_InvalidMatrix:
+  case Match_InvalidMatrix8:
+  case Match_InvalidMatrix16:
   case Match_InvalidMatrix32:
   case Match_InvalidMatrix64:
   case Match_InvalidMatrixTileVectorH8:
   case Match_InvalidMatrixTileVectorH16:
   case Match_InvalidMatrixTileVectorH32:
   case Match_InvalidMatrixTileVectorH64:
   case Match_InvalidMatrixTileVectorH128:
   case Match_InvalidMatrixTileVectorV8:

llvm/lib/Target/AArch64/SMEInstrFormats.td

multiclass sme2_unpk_vector_vg4<string mnemonic, bit u> {
   def _H : sme2_unpk_vector_vg4<0b01, u, ZZZZ_h_mul_r, ZZ_b_mul_r, mnemonic>;
   def _S : sme2_unpk_vector_vg4<0b10, u, ZZZZ_s_mul_r, ZZ_h_mul_r, mnemonic>;
   def _D : sme2_unpk_vector_vg4<0b11, u, ZZZZ_d_mul_r, ZZ_s_mul_r, mnemonic>;
 }
 
 //===----------------------------------------------------------------------===//
 // SME2 multi-vec ZIP four registers
 //===----------------------------------------------------------------------===//
 
 class sme2_zip_vector_vg4<bits<2> sz, bit q, bit op,
                           RegisterOperand first_vector_ty,
                           RegisterOperand second_vector_ty, string mnemonic>
     : sme2_unpk_vector_vg24<sz, 0b0, first_vector_ty, second_vector_ty,
                             mnemonic> {
   bits<3> Zn;
   bits<3> Zd;
   let Inst{20}  = 0b1;
   let Inst{17}  = 0b1;
   let Inst{16}  = q;
   let Inst{9-7} = Zn;
   let Inst{6-5} = 0b00;
   let Inst{4-2} = Zd;
   let Inst{1}   = op;
 }
 
 multiclass sme2_zip_vector_vg4<string mnemonic, bit op> {
   def _B : sme2_zip_vector_vg4<0b00, 0b0, op, ZZZZ_b_mul_r, ZZZZ_b_mul_r, mnemonic>;
   def _H : sme2_zip_vector_vg4<0b01, 0b0, op, ZZZZ_h_mul_r, ZZZZ_h_mul_r, mnemonic>;
   def _S : sme2_zip_vector_vg4<0b10, 0b0, op, ZZZZ_s_mul_r, ZZZZ_s_mul_r, mnemonic>;
   def _D : sme2_zip_vector_vg4<0b11, 0b0, op, ZZZZ_d_mul_r, ZZZZ_d_mul_r, mnemonic>;
   def _Q : sme2_zip_vector_vg4<0b00, 0b1, op, ZZZZ_q_mul_r, ZZZZ_q_mul_r, mnemonic>;
 }
 
 class sme2_zip_vector_vg2<bits<2> sz, bit q, bit op,
                           RegisterOperand multi_vector_ty, ZPRRegOp vector_ty,
                            string mnemonic>
     : I<(outs multi_vector_ty:$Zd), (ins vector_ty:$Zn, vector_ty:$Zm),
         mnemonic, "\t$Zd, $Zn, $Zm",
         "", []>, Sched<[]> {
   bits<5> Zm;

 
 multiclass sme2_zip_vector_vg2<string mnemonic, bit op> {
   def _B : sme2_zip_vector_vg2<0b00, 0b0, op, ZZ_b_mul_r, ZPR8, mnemonic>;
   def _H : sme2_zip_vector_vg2<0b01, 0b0, op, ZZ_h_mul_r, ZPR16, mnemonic>;
   def _S : sme2_zip_vector_vg2<0b10, 0b0, op, ZZ_s_mul_r, ZPR32, mnemonic>;
   def _D : sme2_zip_vector_vg2<0b11, 0b0, op, ZZ_d_mul_r, ZPR64, mnemonic>;
   def _Q : sme2_zip_vector_vg2<0b00, 0b1, op, ZZ_q_mul_r, ZPR128, 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>;
+
+}
+
+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,
+                                           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 Constraints = "$ZAd = $_ZAd";
+}
+
+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,
+                                                !if(v, TileVectorOpV8,
+                                                       TileVectorOpH8),
+                                                uimm2s4range, ZZZZ_b_mul_r,
+                                                mnemonic> {
+    bits<2> imm;
+    let Inst{2}   = 0b0;
+    let Inst{1-0} = imm;
+  }
+
+  def _H : sme2_mova_vec_to_tile_vg4_multi_base<0b01, v,
+                                                !if(v, TileVectorOpV16,
+                                                       TileVectorOpH16),
+                                                uimm1s4range, ZZZZ_h_mul_r,
+                                                mnemonic> {
+    bits<1> ZAd;
+    bits<1> imm;
+    let Inst{2}   = 0b0;
+    let Inst{1}   = ZAd;
+    let Inst{0}   = imm;
+  }
+
+  def _S : sme2_mova_vec_to_tile_vg4_multi_base<0b10, v,
+                                                !if(v, TileVectorOpV32,
+                                                       TileVectorOpH32),
+                                                 uimm0s4range, ZZZZ_s_mul_r,
+                                                 mnemonic> {
+    bits<2> ZAd;
+    let Inst{2}   = 0b0;
+    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>;
+}
+
+class sme2_mova_vec_to_array_vg24_multi<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{5-3}   = 0b000;
+  let Inst{2-0}   = imm;
+
+  let Constraints = "$ZAd = $_ZAd";
+}
+
+multiclass sme2_mova_vec_to_array_vg2_multi<string mnemonic> {
+  def NAME : sme2_mova_vec_to_array_vg24_multi<MatrixOp64, ZZ_d_mul_r,
+                                               mnemonic, "vgx2">{
+   bits<4> Zn;
+   let Inst{10} = 0b0;
+   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">;
+}
+
+multiclass sme2_mova_vec_to_array_vg4_multi<string mnemonic> {
+  def NAME : sme2_mova_vec_to_array_vg24_multi<MatrixOp64, ZZZZ_d_mul_r,
+                                                mnemonic, "vgx4"> {
+    bits<3> Zn;
+    let Inst{10}  = 0b1;
+    let Inst{9-7} = Zn;
+    let Inst{6}   = 0b0;
+  }
+
+  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>;
+
+}
+
+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>;
+}
+
+
+class sme2_mova_tile_to_vec_vg4_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, 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{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,
+                                                ZZZZ_b_mul_r,
+                                                !if(v, TileVectorOpV8,
+                                                       TileVectorOpH8),
+                                                uimm2s4range, mnemonic> {
+    bits<2> imm;
+    let Inst{7}   = 0b0;
+    let Inst{6-5} = imm;
+  }
+
+  def _H : sme2_mova_tile_to_vec_vg4_multi_base<0b01, v,
+                                                ZZZZ_h_mul_r,
+                                                !if(v, TileVectorOpV16,
+                                                       TileVectorOpH16),
+                                                uimm1s4range, mnemonic> {
+    bits<1> ZAn;
+    bits<1> imm;
+    let Inst{7}   = 0b0;
+    let Inst{6}   = ZAn;
+    let Inst{5}   = imm;
+  }
+
+  def _S : sme2_mova_tile_to_vec_vg4_multi_base<0b10, v,
+                                                ZZZZ_s_mul_r,
+                                                !if(v, TileVectorOpV32,
+                                                       TileVectorOpH32),
+                                                 uimm0s4range, mnemonic> {
+    bits<2> ZAn;
+    let Inst{7}   = 0b0;
+    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>;
+}
+
+class sme2_mova_array_to_vec_vg24_multi<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{9-8}   = 0b00;
+  let Inst{7-5}   = imm;
+  let Inst{0}     = 0b0;
+}
+
+multiclass sme2_mova_array_to_vec_vg2_multi<string mnemonic> {
+  def NAME : sme2_mova_array_to_vec_vg24_multi<ZZ_d_mul_r, MatrixOp64,
+                                               mnemonic, "vgx2">{
+    bits<4> Zd;
+    let Inst{10}  = 0b0;
+    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">;
+}
+
+multiclass sme2_mova_array_to_vec_vg4_multi<string mnemonic> {
+  def NAME : sme2_mova_array_to_vec_vg24_multi<ZZZZ_d_mul_r, MatrixOp64,
+                                               mnemonic, "vgx4">{
+    bits<3> Zd;
+    let Inst{10}  = 0b1;
+    let Inst{4-2} = Zd;
+    let Inst{1}   = 0b0;
+  }
+
+  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">;
+}

llvm/test/MC/AArch64/SME2/mova-diagnostics.s

+// 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]+}}:

llvm/test/MC/AArch64/SME2/mova.s

+// 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 -d --mattr=+sme2 - | FileCheck %s --check-prefix=CHECK-INST
+// RUN: llvm-mc -triple=aarch64 -filetype=obj -mattr=+sme2 < %s \
+// RUN:        | llvm-objdump -d - | 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>
+