[AArch64]SME2 single-multi and multi-multi INT dot product instructions[part2]

[CarolineConcatto]

Summary

This patch adds the assembly/disassembly for the following instructions:

    SDOT: (4-way, multiple and single vector): Multi-vector signed integer dot-product by vector.
          SDOT (4-way, multiple vectors): Multi-vector signed integer dot-product.
    UDOT: (4-way, multiple and single vector): Multi-vector unsigned integer dot-product by vector.
          (4-way, multiple vectors): Multi-vector unsigned integer dot-product.
for groups of 2 and 4 ZA registers

The reference can be found here:

https://developer.arm.com/documentation/ddi0602/2022-09

Depends on: D135563

[CarolineConcatto]

-Rebase and fix unwanted change in the test

[CarolineConcatto]

These instructions are now in https://reviews.llvm.org/D135683

[CarolineConcatto]

Wrong patch

[CarolineConcatto]

Create generic multiclass for each class

[CarolineConcatto]

Remove the 4way classes and reuse the ones from D135683

[paulwalker-arm]

I have an observation regarding the quantity of tests but that's just something to consider for later patches (or later refactoring). The patch itself looks good to me.

I've not mentioned this before because the tests can be easily changed later but this patch with its handful of instructions best highlights my next point. There seems to be far more tests than the variability of the instruction encoding would suggest is necessary. Taking udot za.d[w#, #, vgx4], {z#.t - z#.t}, z#.t as an example, this one variant has 40+ tests. Tests are good and all but for something that reuses much of decoding operands and classes of other instructions it seems excessive. Another example is checking { z0.b - z1.b } is synonymous with { z0.b, z1.b }. This seems like something we can test in isolation rather than duplicating every equivalent test across all opcodes.

llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td

 defm SDOT_VG2_M2ZZI_HToS : sme2_dot_array_vg2_index_HToS<"sdot", 0b1000>;
 defm SDOT_VG2_M2ZZI_BToS : sme2_dot_array_vg2_index_BToS<"sdot", 0b1100>;
 defm SDOT_VG4_M4ZZI_HToS : sme2_dot_array_vg4_index_HtoS<"sdot", 0b1000>;
 defm SDOT_VG4_M4ZZI_BToS : sme2_dot_array_vg4_index_BtoS<"sdot", 0b1100>;
 defm SDOT_VG2_M2ZZ_HtoS : sme2_int_dot_array_vg2_single_2way<"sdot", 0b0>;
 defm SDOT_VG4_M4ZZ_HtoS : sme2_int_dot_array_vg4_single_2way<"sdot", 0b0>;
 defm SDOT_VG2_M2Z2Z_HtoS : sme2_int_dot_array_vg2_multi_2way<"sdot", 0b0>;
 defm SDOT_VG4_M4Z4Z_HtoS : sme2_int_dot_array_vg4_multi_2way<"sdot", 0b0>;
+defm SDOT_VG2_M2ZZ_BtoS : sme2_int_dot_array_vg2_single_BtoS<"sdot", 0b0>;
+defm SDOT_VG4_M4ZZ_BtoS : sme2_int_dot_array_vg4_single_BtoS<"sdot", 0b0>;
+defm SDOT_VG2_M2Z2Z_BtoS : sme2_int_dot_array_vg2_multi_BtoS<"sdot", 0b0>;
+defm SDOT_VG4_M4Z4Z_BtoS : sme2_int_dot_array_vg4_multi_BtoS<"sdot", 0b0>;
 
 
 defm SUDOT_VG2_M2ZZI : sme2_dot_array_vg2_index_BToS<"sudot",  0b1111>;
 defm SUDOT_VG4_M4ZZI : sme2_dot_array_vg4_index_BtoS<"sudot",  0b1111>;
 defm SUDOT_VG2_M2ZZ  : sme2_int_dot_array_vg2_single<"sudot", 0b1>;
 defm SUDOT_VG4_M4ZZ  : sme2_int_dot_array_vg4_single<"sudot", 0b1>;
 
 
 defm SVDOT_VG2_M2ZZI      : sme2_dot_array_vg2_index_HToS<"svdot",  0b0100>;
 defm SVDOT_VG4_M4ZZI_BtoS : sme2_dot_array_vg4_index_BtoS<"svdot",  0b0100>;
 defm SUVDOT_VG4_M4ZZI : sme2_dot_array_vg4_index_BtoS<"suvdot", 0b0111>;
 
 defm UDOT_VG2_M2ZZI_HToS : sme2_dot_array_vg2_index_HToS<"udot", 0b1010>;
 defm UDOT_VG2_M2ZZI_BToS : sme2_dot_array_vg2_index_BToS<"udot", 0b1110>;
 defm UDOT_VG4_M4ZZI_BtoS : sme2_dot_array_vg4_index_BtoS<"udot", 0b1110>;
 defm UDOT_VG4_M4ZZI_HToS : sme2_dot_array_vg4_index_HtoS<"udot", 0b1010>;
 defm UDOT_VG2_M2ZZ_HtoS : sme2_int_dot_array_vg2_single_2way<"udot", 0b1>;
 defm UDOT_VG4_M4ZZ_HtoS : sme2_int_dot_array_vg4_single_2way<"udot", 0b1>;
 defm UDOT_VG2_M2Z2Z_HtoS : sme2_int_dot_array_vg2_multi_2way<"udot", 0b1>;
 defm UDOT_VG4_M4Z4Z_HtoS : sme2_int_dot_array_vg4_multi_2way<"udot", 0b1>;
+defm UDOT_VG2_M2ZZ_BtoS : sme2_int_dot_array_vg2_single_BtoS<"udot", 0b1>;
+defm UDOT_VG4_M4ZZ_BtoS : sme2_int_dot_array_vg4_single_BtoS<"udot", 0b1>;
+defm UDOT_VG2_M2Z2Z_BtoS : sme2_int_dot_array_vg2_multi_BtoS<"udot", 0b1>;
+defm UDOT_VG4_M4Z4Z_BtoS : sme2_int_dot_array_vg4_multi_BtoS<"udot", 0b1>;
 
 defm USDOT_VG2_M2ZZI : sme2_dot_array_vg2_index_BToS<"usdot",  0b1101>;
 defm USDOT_VG4_M4ZZI : sme2_dot_array_vg4_index_BtoS<"usdot",  0b1101>;
 defm USDOT_VG2_M2ZZ  : sme2_int_dot_array_vg2_single<"usdot", 0b0>;
 defm USDOT_VG4_M4ZZ  : sme2_int_dot_array_vg4_single<"usdot", 0b0>;
 defm USDOT_VG2_M2Z2Z : sme2_int_dot_array_vg2_multi<"usdot">;
 defm USDOT_VG4_M4Z4Z : sme2_int_dot_array_vg4_multi<"usdot">;
 

 
 defm SUB_VG2_M2ZZ_D  : sme2_mul_add_sub_array_vg2_single_D<"sub", 0b11>;
 defm SUB_VG4_M4ZZ_D  : sme2_mul_add_sub_array_vg4_single_D<"sub", 0b11>;
 defm SUB_VG2_M2Z2Z_D : sme2_mul_add_sub_array_vg2_multi_D<"sub", 0b11>;
 defm SUB_VG4_M4Z4Z_D : sme2_mul_add_sub_array_vg4_multi_D<"sub", 0b11>;
 
 defm SDOT_VG2_M2ZZI_HtoD : sme2_dot_array_vg2_index<"sdot",  0b01>;
 defm SDOT_VG4_M4ZZI_HtoD : sme2_dot_array_vg4_index<"sdot",  0b001>;
+defm SDOT_VG2_M2ZZ_HtoD : sme2_int_dot_array_vg2_single_HtoD<"sdot", 0b0>;
+defm SDOT_VG4_M4ZZ_HtoD : sme2_int_dot_array_vg4_single_HtoD<"sdot", 0b0>;
+defm SDOT_VG2_M2Z2Z_HtoD : sme2_int_dot_array_vg2_multi_HtoD<"sdot", 0b0>;
+defm SDOT_VG4_M4Z4Z_HtoD : sme2_int_dot_array_vg4_multi_HtoD<"sdot", 0b0>;
 
 defm SVDOT_VG4_M4ZZI_HtoD : sme2_dot_array_vg4_index<"svdot", 0b101>;
 
 defm UDOT_VG2_M2ZZI_HtoD : sme2_dot_array_vg2_index<"udot", 0b11>;
 defm UDOT_VG4_M4ZZI_HtoD : sme2_dot_array_vg4_index<"udot",  0b011>;
+defm UDOT_VG2_M2ZZ_HtoD : sme2_int_dot_array_vg2_single_HtoD<"udot", 0b1>;
+defm UDOT_VG4_M4ZZ_HtoD : sme2_int_dot_array_vg4_single_HtoD<"udot", 0b1>;
+defm UDOT_VG2_M2Z2Z_HtoD : sme2_int_dot_array_vg2_multi_HtoD<"udot", 0b1>;
+defm UDOT_VG4_M4Z4Z_HtoD : sme2_int_dot_array_vg4_multi_HtoD<"udot", 0b1>;
 
 defm UVDOT_VG4_M4ZZI_HtoD : sme2_dot_array_vg4_index<"uvdot", 0b111>;
 }
 
 let Predicates = [HasSME2, HasSMEF64] in {
 defm FMLA_VG2_M2ZZ_D  : sme2_mul_add_sub_array_vg2_single_D<"fmla", 0b00>;
 defm FMLA_VG4_M4ZZ_D  : sme2_mul_add_sub_array_vg4_single_D<"fmla", 0b00>;
 defm FMLA_VG2_M2Z2Z_D : sme2_mul_add_sub_array_vg2_multi_D<"fmla", 0b00>;

llvm/lib/Target/AArch64/SMEInstrFormats.td

 
 multiclass sme2_int_dot_array_vg4_single<string mnemonic, bit u> {
   def _BtoS: sme2_int_dot_array_vg24_single_2way<0b0, 0b1, u, ZZZZ_b_r, ZPR4b8, mnemonic>;
 
   def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
         (!cast<Instruction>(NAME # _BtoS) MatrixOp32:$ZAda,  MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZZZ_b_r:$Zn, ZPR4b8:$Zm), 0>;
 }
 
+class sme2_int_dot_array_vg24_single_4way<bit sz, bit vg4, bit u,
+                                          MatrixOperand matrix_ty,
+                                          RegisterOperand multi_vector_ty,
+                                          ZPRRegOp zpr_ty,
+                                          string mnemonic>
+    : I<(outs matrix_ty:$ZAda),
+        (ins matrix_ty:$_ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3,
+         multi_vector_ty:$Zn, zpr_ty:$Zm),
+        mnemonic, "\t$ZAda[$Rv, $imm3, " # !if(vg4, "vgx4", "vgx2") # "], $Zn, $Zm",
+        "", []>, Sched<[]> {
+  bits<4> Zm;
+  bits<2> Rv;
+  bits<5> Zn;
+  bits<3> imm3;
+  let Inst{31-23} = 0b110000010;
+  let Inst{22}    = sz;
+  let Inst{21}    = 0b1;
+  let Inst{20}    = vg4;
+  let Inst{19-16} = Zm;
+  let Inst{15}    = 0b0;
+  let Inst{14-13} = Rv;
+  let Inst{12-10} = 0b101;
+  let Inst{9-5}   = Zn;
+  let Inst{4}     = u;
+  let Inst{3}     = 0b0;
+  let Inst{2-0}   = imm3;
+
+  let Constraints = "$ZAda = $_ZAda";
+}
+
+// SME2 single-multi four-way dot product two registers
+
+multiclass sme2_int_dot_array_vg2_single_BtoS<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_single_4way<0b0, 0b0, u, MatrixOp32, ZZ_b_r, ZPR4b8, mnemonic>;
+
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME)  MatrixOp32:$ZAda,  MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZ_b_r:$Zn, ZPR4b8:$Zm), 0>;
+}
+
+multiclass sme2_int_dot_array_vg2_single_HtoD<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_single_4way<0b1, 0b0, u, MatrixOp64, ZZ_h_r, ZPR4b16, mnemonic>;
+
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME)  MatrixOp64:$ZAda,  MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZ_h_r:$Zn, ZPR4b16:$Zm), 0>;
+}
+
+// SME2 single-multi four-way dot product four registers
+
+multiclass sme2_int_dot_array_vg4_single_BtoS<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_single_4way<0b0, 0b1, u, MatrixOp32, ZZZZ_b_r, ZPR4b8, mnemonic>;
+
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME)  MatrixOp32:$ZAda,  MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZZZ_b_r:$Zn, ZPR4b8:$Zm), 0>;
+}
+multiclass sme2_int_dot_array_vg4_single_HtoD<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_single_4way<0b1, 0b1, u, MatrixOp64, ZZZZ_h_r, ZPR4b16, mnemonic>;
+
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME)  MatrixOp64:$ZAda,  MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZZZ_h_r:$Zn, ZPR4b16:$Zm), 0>;
+}
+
 class sme2_int_dot_array_vg24_multi_2way<bit op0, bit u, RegisterOperand multi_vector_ty,
                                           string mnemonic, string vg_acronym>
     : I<(outs MatrixOp32:$ZAda),
         (ins MatrixOp32:$_ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3,
          multi_vector_ty:$Zn, multi_vector_ty:$Zm),
         mnemonic, "\t$ZAda[$Rv, $imm3, " # vg_acronym # "], $Zn, $Zm",
         "", []>, Sched<[]> {
   bits<2> Rv;
def _BtoS : sme2_int_dot_array_vg24_multi_2way<0b0, 0b0, ZZZZ_b_mul_r, mnemonic,
     let Inst{9-7}   = Zn;
     let Inst{6}     = 0b0;
   }
 
   def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
         (!cast<Instruction>(NAME # _BtoS) MatrixOp32:$ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZZZ_b_mul_r:$Zn, ZZZZ_b_mul_r:$Zm), 0>;
 }
 
+class sme2_int_dot_array_vg24_multi_4way<bit sz, bit u,
+                                          MatrixOperand matrix_ty,
+                                          RegisterOperand multi_vector_ty,
+                                          string mnemonic, string vg_acronym>
+    : I<(outs matrix_ty:$ZAda),
+        (ins matrix_ty:$_ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3,
+         multi_vector_ty:$Zn, multi_vector_ty:$Zm),
+        mnemonic, "\t$ZAda[$Rv, $imm3, " # vg_acronym # "], $Zn, $Zm",
+        "", []>, Sched<[]> {
+  bits<2> Rv;
+  bits<3> imm3;
+  let Inst{31-23} = 0b110000011;
+  let Inst{22}    = sz;
+  let Inst{21}    = 0b1;
+  let Inst{15}    = 0b0;
+  let Inst{14-13} = Rv;
+  let Inst{12-10} = 0b101;
+  let Inst{5}     = 0b0;
+  let Inst{4}     = u;
+  let Inst{3}     = 0b0;
+  let Inst{2-0}   = imm3;
+
+  let Constraints = "$ZAda = $_ZAda";
+}
+
+// SME2 multi four-way dot product two registers
+
+multiclass sme2_int_dot_array_vg2_multi_BtoS<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_multi_4way<0b0, u, MatrixOp32, ZZ_b_mul_r,
+                                           mnemonic, "vgx2"> {
+    bits<4> Zm;
+    bits<4> Zn;
+    let Inst{20-17} = Zm;
+    let Inst{16}    = 0b0;
+    let Inst{9-6}   = Zn;
+  }
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME) MatrixOp32:$ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZ_b_mul_r:$Zn, ZZ_b_mul_r:$Zm), 0>;
+}
+
+multiclass sme2_int_dot_array_vg2_multi_HtoD<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_multi_4way<0b1, u, MatrixOp64, ZZ_h_mul_r,
+                                           mnemonic, "vgx2"> {
+    bits<4> Zm;
+    bits<4> Zn;
+    let Inst{20-17} = Zm;
+    let Inst{16}    = 0b0;
+    let Inst{9-6}   = Zn;
+  }
+
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME) MatrixOp64:$ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZ_h_mul_r:$Zn, ZZ_h_mul_r:$Zm), 0>;
+}
+
+// SME2 multi four-way dot product four registers
+multiclass sme2_int_dot_array_vg4_multi_BtoS<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_multi_4way<0b0, u, MatrixOp32, ZZZZ_b_mul_r,
+                                           mnemonic, "vgx4"> {
+    bits<3> Zm;
+    bits<3> Zn;
+    let Inst{20-18} = Zm;
+    let Inst{17-16} = 0b01;
+    let Inst{9-7}   = Zn;
+    let Inst{6}     = 0b0;
+  }
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME) MatrixOp32:$ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZZZ_b_mul_r:$Zn, ZZZZ_b_mul_r:$Zm), 0>;
+}
+
+multiclass sme2_int_dot_array_vg4_multi_HtoD<string mnemonic, bit u> {
+  def NAME : sme2_int_dot_array_vg24_multi_4way<0b1, u, MatrixOp64, ZZZZ_h_mul_r,
+                                           mnemonic, "vgx4"> {
+    bits<3> Zm;
+    bits<3> Zn;
+    let Inst{20-18} = Zm;
+    let Inst{17-16} = 0b01;
+    let Inst{9-7}   = Zn;
+    let Inst{6}     = 0b0;
+  }
+
+  def : InstAlias<mnemonic # "\t$ZAda[$Rv, $imm3], $Zn, $Zm",
+        (!cast<Instruction>(NAME) MatrixOp64:$ZAda, MatrixIndexGPR32Op8_11:$Rv, sme_elm_idx0_7:$imm3, ZZZZ_h_mul_r:$Zn, ZZZZ_h_mul_r:$Zm), 0>;
+}
 

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

 
 sdot    za.s[w9, 7], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10001111
 // CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
 // CHECK-ENCODING: [0x8f,0x35,0xea,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1ea358f <unknown>
 
 
+sdot    za.s[w8, 0, vgx2], {z0.b-z1.b}, z0.b  // 11000001-00100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x20,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1201400 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z1.b}, z0.b  // 11000001-00100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x20,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1201400 <unknown>
+
+sdot    za.s[w10, 5, vgx2], {z10.b-z11.b}, z5.b  // 11000001-00100101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x25,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1255545 <unknown>
+
+sdot    za.s[w10, 5], {z10.b-z11.b}, z5.b  // 11000001-00100101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x25,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1255545 <unknown>
+
+sdot    za.s[w11, 7, vgx2], {z13.b-z14.b}, z8.b  // 11000001-00101000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z13.b-z14.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x28,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12875a7 <unknown>
+
+sdot    za.s[w11, 7], {z13.b-z14.b}, z8.b  // 11000001-00101000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z13.b-z14.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x28,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12875a7 <unknown>
+
+sdot    za.s[w11, 7, vgx2], {z31.b-z0.b}, z15.b  // 11000001-00101111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z31.b-z0.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x2f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12f77e7 <unknown>
+
+sdot    za.s[w11, 7], {z31.b-z0.b}, z15.b  // 11000001-00101111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z31.b-z0.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x2f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12f77e7 <unknown>
+
+sdot    za.s[w8, 5, vgx2], {z17.b-z18.b}, z0.b  // 11000001-00100000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z17.b-z18.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x20,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1201625 <unknown>
+
+sdot    za.s[w8, 5], {z17.b-z18.b}, z0.b  // 11000001-00100000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z17.b-z18.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x20,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1201625 <unknown>
+
+sdot    za.s[w8, 1, vgx2], {z1.b-z2.b}, z14.b  // 11000001-00101110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z1.b-z2.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x2e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12e1421 <unknown>
+
+sdot    za.s[w8, 1], {z1.b-z2.b}, z14.b  // 11000001-00101110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z1.b-z2.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x2e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12e1421 <unknown>
+
+sdot    za.s[w10, 0, vgx2], {z19.b-z20.b}, z4.b  // 11000001-00100100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z19.b-z20.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x24,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1245660 <unknown>
+
+sdot    za.s[w10, 0], {z19.b-z20.b}, z4.b  // 11000001-00100100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z19.b-z20.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x24,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1245660 <unknown>
+
+sdot    za.s[w8, 0, vgx2], {z12.b-z13.b}, z2.b  // 11000001-00100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x22,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1221580 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z13.b}, z2.b  // 11000001-00100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x22,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1221580 <unknown>
+
+sdot    za.s[w10, 1, vgx2], {z1.b-z2.b}, z10.b  // 11000001-00101010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z1.b-z2.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x2a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12a5421 <unknown>
+
+sdot    za.s[w10, 1], {z1.b-z2.b}, z10.b  // 11000001-00101010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z1.b-z2.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x2a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12a5421 <unknown>
+
+sdot    za.s[w8, 5, vgx2], {z22.b-z23.b}, z14.b  // 11000001-00101110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x2e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12e16c5 <unknown>
+
+sdot    za.s[w8, 5], {z22.b-z23.b}, z14.b  // 11000001-00101110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x2e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12e16c5 <unknown>
+
+sdot    za.s[w11, 2, vgx2], {z9.b-z10.b}, z1.b  // 11000001-00100001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z9.b-z10.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x21,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1217522 <unknown>
+
+sdot    za.s[w11, 2], {z9.b-z10.b}, z1.b  // 11000001-00100001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z9.b-z10.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x21,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1217522 <unknown>
+
+sdot    za.s[w9, 7, vgx2], {z12.b-z13.b}, z11.b  // 11000001-00101011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x2b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12b3587 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z13.b}, z11.b  // 11000001-00101011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x2b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c12b3587 <unknown>
+
+
 sdot    za.s[w8, 0, vgx2], {z0.b-z1.b}, z0.b[0]  // 11000001-01010000-00010000-00100000
 // CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b[0]
 // CHECK-ENCODING: [0x20,0x10,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1501020 <unknown>
 
 sdot    za.s[w8, 0], {z0.b-z1.b}, z0.b[0]  // 11000001-01010000-00010000-00100000
 // CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b[0]

 
 sdot    za.s[w9, 7], {z12.b-z13.b}, z11.b[2]  // 11000001-01011011-00111001-10100111
 // CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b[2]
 // CHECK-ENCODING: [0xa7,0x39,0x5b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c15b39a7 <unknown>
 
 
+sdot    za.s[w8, 0, vgx2], {z0.b-z1.b}, {z0.b-z1.b}  // 11000001-10100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x00,0x14,0xa0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a01400 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z1.b}, {z0.b-z1.b}  // 11000001-10100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x00,0x14,0xa0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a01400 <unknown>
+
+sdot    za.s[w10, 5, vgx2], {z10.b-z11.b}, {z20.b-z21.b}  // 11000001-10110100-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x45,0x55,0xb4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b45545 <unknown>
+
+sdot    za.s[w10, 5], {z10.b-z11.b}, {z20.b-z21.b}  // 11000001-10110100-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x45,0x55,0xb4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b45545 <unknown>
+
+sdot    za.s[w11, 7, vgx2], {z12.b-z13.b}, {z8.b-z9.b}  // 11000001-10101000-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.b-z13.b }, { z8.b-z9.b }
+// CHECK-ENCODING: [0x87,0x75,0xa8,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a87587 <unknown>
+
+sdot    za.s[w11, 7], {z12.b-z13.b}, {z8.b-z9.b}  // 11000001-10101000-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.b-z13.b }, { z8.b-z9.b }
+// CHECK-ENCODING: [0x87,0x75,0xa8,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a87587 <unknown>
+
+sdot    za.s[w11, 7, vgx2], {z30.b-z31.b}, {z30.b-z31.b}  // 11000001-10111110-01110111-11000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.b-z31.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc7,0x77,0xbe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1be77c7 <unknown>
+
+sdot    za.s[w11, 7], {z30.b-z31.b}, {z30.b-z31.b}  // 11000001-10111110-01110111-11000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.b-z31.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc7,0x77,0xbe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1be77c7 <unknown>
+
+sdot    za.s[w8, 5, vgx2], {z16.b-z17.b}, {z16.b-z17.b}  // 11000001-10110000-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.b-z17.b }, { z16.b-z17.b }
+// CHECK-ENCODING: [0x05,0x16,0xb0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b01605 <unknown>
+
+sdot    za.s[w8, 5], {z16.b-z17.b}, {z16.b-z17.b}  // 11000001-10110000-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.b-z17.b }, { z16.b-z17.b }
+// CHECK-ENCODING: [0x05,0x16,0xb0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b01605 <unknown>
+
+sdot    za.s[w8, 1, vgx2], {z0.b-z1.b}, {z30.b-z31.b}  // 11000001-10111110-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.b-z1.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1be1401 <unknown>
+
+sdot    za.s[w8, 1], {z0.b-z1.b}, {z30.b-z31.b}  // 11000001-10111110-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.b-z1.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1be1401 <unknown>
+
+sdot    za.s[w10, 0, vgx2], {z18.b-z19.b}, {z20.b-z21.b}  // 11000001-10110100-01010110-01000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.b-z19.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x40,0x56,0xb4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b45640 <unknown>
+
+sdot    za.s[w10, 0], {z18.b-z19.b}, {z20.b-z21.b}  // 11000001-10110100-01010110-01000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.b-z19.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x40,0x56,0xb4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b45640 <unknown>
+
+sdot    za.s[w8, 0, vgx2], {z12.b-z13.b}, {z2.b-z3.b}  // 11000001-10100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, { z2.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa2,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a21580 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z13.b}, {z2.b-z3.b}  // 11000001-10100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, { z2.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa2,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a21580 <unknown>
+
+sdot    za.s[w10, 1, vgx2], {z0.b-z1.b}, {z26.b-z27.b}  // 11000001-10111010-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.b-z1.b }, { z26.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xba,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1ba5401 <unknown>
+
+sdot    za.s[w10, 1], {z0.b-z1.b}, {z26.b-z27.b}  // 11000001-10111010-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.b-z1.b }, { z26.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xba,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1ba5401 <unknown>
+
+sdot    za.s[w8, 5, vgx2], {z22.b-z23.b}, {z30.b-z31.b}  // 11000001-10111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc5,0x16,0xbe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1be16c5 <unknown>
+
+sdot    za.s[w8, 5], {z22.b-z23.b}, {z30.b-z31.b}  // 11000001-10111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc5,0x16,0xbe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1be16c5 <unknown>
+
+sdot    za.s[w11, 2, vgx2], {z8.b-z9.b}, {z0.b-z1.b}  // 11000001-10100000-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.b-z9.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x02,0x75,0xa0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a07502 <unknown>
+
+sdot    za.s[w11, 2], {z8.b-z9.b}, {z0.b-z1.b}  // 11000001-10100000-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.b-z9.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x02,0x75,0xa0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a07502 <unknown>
+
+sdot    za.s[w9, 7, vgx2], {z12.b-z13.b}, {z10.b-z11.b}  // 11000001-10101010-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, { z10.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xaa,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1aa3587 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z13.b}, {z10.b-z11.b}  // 11000001-10101010-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, { z10.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xaa,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1aa3587 <unknown>
+
+
+sdot    za.d[w8, 0, vgx2], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x60,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1601400 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x60,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1601400 <unknown>
+
+sdot    za.d[w10, 5, vgx2], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x65,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1655545 <unknown>
+
+sdot    za.d[w10, 5], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x65,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1655545 <unknown>
+
+sdot    za.d[w11, 7, vgx2], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z13.h-z14.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x68,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16875a7 <unknown>
+
+sdot    za.d[w11, 7], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z13.h-z14.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x68,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16875a7 <unknown>
+
+sdot    za.d[w11, 7, vgx2], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z31.h-z0.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x6f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16f77e7 <unknown>
+
+sdot    za.d[w11, 7], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z31.h-z0.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x6f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16f77e7 <unknown>
+
+sdot    za.d[w8, 5, vgx2], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z17.h-z18.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x60,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1601625 <unknown>
+
+sdot    za.d[w8, 5], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z17.h-z18.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x60,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1601625 <unknown>
+
+sdot    za.d[w8, 1, vgx2], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z1.h-z2.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x6e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16e1421 <unknown>
+
+sdot    za.d[w8, 1], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z1.h-z2.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x6e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16e1421 <unknown>
+
+sdot    za.d[w10, 0, vgx2], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z19.h-z20.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x64,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1645660 <unknown>
+
+sdot    za.d[w10, 0], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z19.h-z20.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x64,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1645660 <unknown>
+
+sdot    za.d[w8, 0, vgx2], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x62,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1621580 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x62,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1621580 <unknown>
+
+sdot    za.d[w10, 1, vgx2], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z1.h-z2.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x6a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16a5421 <unknown>
+
+sdot    za.d[w10, 1], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z1.h-z2.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x6a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16a5421 <unknown>
+
+sdot    za.d[w8, 5, vgx2], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x6e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16e16c5 <unknown>
+
+sdot    za.d[w8, 5], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x6e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16e16c5 <unknown>
+
+sdot    za.d[w11, 2, vgx2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z9.h-z10.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x61,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1617522 <unknown>
+
+sdot    za.d[w11, 2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z9.h-z10.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x61,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1617522 <unknown>
+
+sdot    za.d[w9, 7, vgx2], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x6b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16b3587 <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x6b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c16b3587 <unknown>
+
+
 sdot    za.d[w8, 0, vgx2], {z0.h-z1.h}, z0.h[0]  // 11000001-11010000-00000000-00001000
 // CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
 // CHECK-ENCODING: [0x08,0x00,0xd0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1d00008 <unknown>
 
 sdot    za.d[w8, 0], {z0.h-z1.h}, z0.h[0]  // 11000001-11010000-00000000-00001000
 // CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]

 
 sdot    za.d[w9, 7], {z12.h-z13.h}, z11.h[0]  // 11000001-11011011-00100001-10001111
 // CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h[0]
 // CHECK-ENCODING: [0x8f,0x21,0xdb,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1db218f <unknown>
 
 
+sdot    za.d[w8, 0, vgx2], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x00,0x14,0xe0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e01400 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x00,0x14,0xe0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e01400 <unknown>
+
+sdot    za.d[w10, 5, vgx2], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x45,0x55,0xf4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f45545 <unknown>
+
+sdot    za.d[w10, 5], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x45,0x55,0xf4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f45545 <unknown>
+
+sdot    za.d[w11, 7, vgx2], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
+// CHECK-ENCODING: [0x87,0x75,0xe8,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e87587 <unknown>
+
+sdot    za.d[w11, 7], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
+// CHECK-ENCODING: [0x87,0x75,0xe8,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e87587 <unknown>
+
+sdot    za.d[w11, 7, vgx2], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc7,0x77,0xfe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fe77c7 <unknown>
+
+sdot    za.d[w11, 7], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc7,0x77,0xfe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fe77c7 <unknown>
+
+sdot    za.d[w8, 5, vgx2], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
+// CHECK-ENCODING: [0x05,0x16,0xf0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f01605 <unknown>
+
+sdot    za.d[w8, 5], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
+// CHECK-ENCODING: [0x05,0x16,0xf0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f01605 <unknown>
+
+sdot    za.d[w8, 1, vgx2], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fe1401 <unknown>
+
+sdot    za.d[w8, 1], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fe1401 <unknown>
+
+sdot    za.d[w10, 0, vgx2], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x40,0x56,0xf4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f45640 <unknown>
+
+sdot    za.d[w10, 0], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x40,0x56,0xf4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f45640 <unknown>
+
+sdot    za.d[w8, 0, vgx2], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe2,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e21580 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe2,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e21580 <unknown>
+
+sdot    za.d[w10, 1, vgx2], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xfa,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fa5401 <unknown>
+
+sdot    za.d[w10, 1], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xfa,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fa5401 <unknown>
+
+sdot    za.d[w8, 5, vgx2], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc5,0x16,0xfe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fe16c5 <unknown>
+
+sdot    za.d[w8, 5], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc5,0x16,0xfe,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fe16c5 <unknown>
+
+sdot    za.d[w11, 2, vgx2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x02,0x75,0xe0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e07502 <unknown>
+
+sdot    za.d[w11, 2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x02,0x75,0xe0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e07502 <unknown>
+
+sdot    za.d[w9, 7, vgx2], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xea,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1ea3587 <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xea,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1ea3587 <unknown>
+
+
 sdot    za.s[w8, 0, vgx4], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00001000
 // CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h
 // CHECK-ENCODING: [0x08,0x14,0x70,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1701408 <unknown>
 
 sdot    za.s[w8, 0], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00001000
 // CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h

 
 sdot    za.s[w9, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10001111
 // CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
 // CHECK-ENCODING: [0x8f,0x35,0xe9,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1e9358f <unknown>
 
 
+sdot    za.s[w8, 0, vgx4], {z0.b-z3.b}, z0.b  // 11000001-00110000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301400 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z3.b}, z0.b  // 11000001-00110000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301400 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z10.b-z13.b}, z5.b  // 11000001-00110101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z10.b-z13.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x35,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1355545 <unknown>
+
+sdot    za.s[w10, 5], {z10.b-z13.b}, z5.b  // 11000001-00110101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z10.b-z13.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x35,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1355545 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z13.b-z16.b}, z8.b  // 11000001-00111000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z13.b-z16.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x38,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13875a7 <unknown>
+
+sdot    za.s[w11, 7], {z13.b-z16.b}, z8.b  // 11000001-00111000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z13.b-z16.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x38,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13875a7 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z31.b-z2.b}, z15.b  // 11000001-00111111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z31.b-z2.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x3f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13f77e7 <unknown>
+
+sdot    za.s[w11, 7], {z31.b-z2.b}, z15.b  // 11000001-00111111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z31.b-z2.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x3f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13f77e7 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z17.b-z20.b}, z0.b  // 11000001-00110000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z17.b-z20.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301625 <unknown>
+
+sdot    za.s[w8, 5], {z17.b-z20.b}, z0.b  // 11000001-00110000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z17.b-z20.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301625 <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z1.b-z4.b}, z14.b  // 11000001-00111110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z1.b-z4.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e1421 <unknown>
+
+sdot    za.s[w8, 1], {z1.b-z4.b}, z14.b  // 11000001-00111110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z1.b-z4.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e1421 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z19.b-z22.b}, z4.b  // 11000001-00110100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z19.b-z22.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x34,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1345660 <unknown>
+
+sdot    za.s[w10, 0], {z19.b-z22.b}, z4.b  // 11000001-00110100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z19.b-z22.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x34,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1345660 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.b-z15.b}, z2.b  // 11000001-00110010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x32,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1321580 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z15.b}, z2.b  // 11000001-00110010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x32,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1321580 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z1.b-z4.b}, z10.b  // 11000001-00111010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z1.b-z4.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x3a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13a5421 <unknown>
+
+sdot    za.s[w10, 1], {z1.b-z4.b}, z10.b  // 11000001-00111010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z1.b-z4.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x3a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13a5421 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z22.b-z25.b}, z14.b  // 11000001-00111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z22.b-z25.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e16c5 <unknown>
+
+sdot    za.s[w8, 5], {z22.b-z25.b}, z14.b  // 11000001-00111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z22.b-z25.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e16c5 <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z9.b-z12.b}, z1.b  // 11000001-00110001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z9.b-z12.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x31,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1317522 <unknown>
+
+sdot    za.s[w11, 2], {z9.b-z12.b}, z1.b  // 11000001-00110001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z9.b-z12.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x31,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1317522 <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.b-z15.b}, z11.b  // 11000001-00111011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x3b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13b3587 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z15.b}, z11.b  // 11000001-00111011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x3b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13b3587 <unknown>
+
+
 sdot    za.s[w8, 0, vgx4], {z0.b-z3.b}, z0.b[0]  // 11000001-01010000-10010000-00100000
 // CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b[0]
 // CHECK-ENCODING: [0x20,0x90,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1509020 <unknown>
 
 sdot    za.s[w8, 0], {z0.b-z3.b}, z0.b[0]  // 11000001-01010000-10010000-00100000
 // CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b[0]

 
 sdot    za.s[w9, 7], {z12.b-z15.b}, z11.b[2]  // 11000001-01011011-10111001-10100111
 // CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b[2]
 // CHECK-ENCODING: [0xa7,0xb9,0x5b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c15bb9a7 <unknown>
 
 
+sdot    za.s[w8, 0, vgx4], {z0.b-z3.b}, {z0.b-z3.b}  // 11000001-10100001-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x00,0x14,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11400 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z3.b}, {z0.b-z3.b}  // 11000001-10100001-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x00,0x14,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11400 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z8.b-z11.b}, {z20.b-z23.b}  // 11000001-10110101-01010101-00000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.b-z11.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x05,0x55,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55505 <unknown>
+
+sdot    za.s[w10, 5], {z8.b-z11.b}, {z20.b-z23.b}  // 11000001-10110101-01010101-00000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.b-z11.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x05,0x55,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55505 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x75,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a97587 <unknown>
+
+sdot    za.s[w11, 7], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x75,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a97587 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z28.b-z31.b}, {z28.b-z31.b}  // 11000001-10111101-01110111-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.b-z31.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x87,0x77,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd7787 <unknown>
+
+sdot    za.s[w11, 7], {z28.b-z31.b}, {z28.b-z31.b}  // 11000001-10111101-01110111-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.b-z31.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x87,0x77,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd7787 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z16.b-z19.b}, {z16.b-z19.b}  // 11000001-10110001-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.b-z19.b }, { z16.b-z19.b }
+// CHECK-ENCODING: [0x05,0x16,0xb1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b11605 <unknown>
+
+sdot    za.s[w8, 5], {z16.b-z19.b}, {z16.b-z19.b}  // 11000001-10110001-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.b-z19.b }, { z16.b-z19.b }
+// CHECK-ENCODING: [0x05,0x16,0xb1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b11605 <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z0.b-z3.b}, {z28.b-z31.b}  // 11000001-10111101-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.b-z3.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1401 <unknown>
+
+sdot    za.s[w8, 1], {z0.b-z3.b}, {z28.b-z31.b}  // 11000001-10111101-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.b-z3.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1401 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z16.b-z19.b}, {z20.b-z23.b}  // 11000001-10110101-01010110-00000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.b-z19.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x00,0x56,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55600 <unknown>
+
+sdot    za.s[w10, 0], {z16.b-z19.b}, {z20.b-z23.b}  // 11000001-10110101-01010110-00000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.b-z19.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x00,0x56,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55600 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.b-z15.b}, {z0.b-z3.b}  // 11000001-10100001-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11580 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z15.b}, {z0.b-z3.b}  // 11000001-10100001-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11580 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z0.b-z3.b}, {z24.b-z27.b}  // 11000001-10111001-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.b-z3.b }, { z24.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xb9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b95401 <unknown>
+
+sdot    za.s[w10, 1], {z0.b-z3.b}, {z24.b-z27.b}  // 11000001-10111001-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.b-z3.b }, { z24.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xb9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b95401 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z20.b-z23.b}, {z28.b-z31.b}  // 11000001-10111101-00010110-10000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.b-z23.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x85,0x16,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1685 <unknown>
+
+sdot    za.s[w8, 5], {z20.b-z23.b}, {z28.b-z31.b}  // 11000001-10111101-00010110-10000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.b-z23.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x85,0x16,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1685 <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z8.b-z11.b}, {z0.b-z3.b}  // 11000001-10100001-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.b-z11.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x02,0x75,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a17502 <unknown>
+
+sdot    za.s[w11, 2], {z8.b-z11.b}, {z0.b-z3.b}  // 11000001-10100001-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.b-z11.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x02,0x75,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a17502 <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a93587 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a93587 <unknown>
+
+
+sdot    za.d[w8, 0, vgx4], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701400 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701400 <unknown>
+
+sdot    za.d[w10, 5, vgx4], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z10.h-z13.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x75,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1755545 <unknown>
+
+sdot    za.d[w10, 5], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z10.h-z13.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x75,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1755545 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z13.h-z16.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x78,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17875a7 <unknown>
+
+sdot    za.d[w11, 7], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z13.h-z16.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x78,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17875a7 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z31.h-z2.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x7f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17f77e7 <unknown>
+
+sdot    za.d[w11, 7], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z31.h-z2.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x7f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17f77e7 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z17.h-z20.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701625 <unknown>
+
+sdot    za.d[w8, 5], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z17.h-z20.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701625 <unknown>
+
+sdot    za.d[w8, 1, vgx4], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z1.h-z4.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e1421 <unknown>
+
+sdot    za.d[w8, 1], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z1.h-z4.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e1421 <unknown>
+
+sdot    za.d[w10, 0, vgx4], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z19.h-z22.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x74,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1745660 <unknown>
+
+sdot    za.d[w10, 0], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z19.h-z22.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x74,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1745660 <unknown>
+
+sdot    za.d[w8, 0, vgx4], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x72,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1721580 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x72,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1721580 <unknown>
+
+sdot    za.d[w10, 1, vgx4], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z1.h-z4.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x7a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17a5421 <unknown>
+
+sdot    za.d[w10, 1], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z1.h-z4.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x7a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17a5421 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z22.h-z25.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e16c5 <unknown>
+
+sdot    za.d[w8, 5], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z22.h-z25.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e16c5 <unknown>
+
+sdot    za.d[w11, 2, vgx4], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z9.h-z12.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x71,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1717522 <unknown>
+
+sdot    za.d[w11, 2], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z9.h-z12.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x71,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1717522 <unknown>
+
+sdot    za.d[w9, 7, vgx4], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x7b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17b3587 <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x7b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17b3587 <unknown>
+
+
 sdot    za.d[w8, 0, vgx4], {z0.h-z3.h}, z0.h[0]  // 11000001-11010000-10000000-00001000
 // CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
 // CHECK-ENCODING: [0x08,0x80,0xd0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1d08008 <unknown>
 
 sdot    za.d[w8, 0], {z0.h-z3.h}, z0.h[0]  // 11000001-11010000-10000000-00001000
 // CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]

 
 sdot    za.d[w9, 7], {z12.h-z15.h}, z11.h[0]  // 11000001-11011011-10100001-10001111
 // CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h[0]
 // CHECK-ENCODING: [0x8f,0xa1,0xdb,0xc1]
 // CHECK-ERROR: instruction requires: sme2
 // CHECK-UNKNOWN: c1dba18f <unknown>
 
 
+sdot    za.d[w8, 0, vgx4], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x00,0x14,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11400 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x00,0x14,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11400 <unknown>
+
+sdot    za.d[w10, 5, vgx4], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x05,0x55,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55505 <unknown>
+
+sdot    za.d[w10, 5], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x05,0x55,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55505 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x75,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e97587 <unknown>
+
+sdot    za.d[w11, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x75,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e97587 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x87,0x77,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd7787 <unknown>
+
+sdot    za.d[w11, 7], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x87,0x77,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd7787 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
+// CHECK-ENCODING: [0x05,0x16,0xf1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f11605 <unknown>
+
+sdot    za.d[w8, 5], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
+// CHECK-ENCODING: [0x05,0x16,0xf1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f11605 <unknown>
+
+sdot    za.d[w8, 1, vgx4], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1401 <unknown>
+
+sdot    za.d[w8, 1], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1401 <unknown>
+
+sdot    za.d[w10, 0, vgx4], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x00,0x56,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55600 <unknown>
+
+sdot    za.d[w10, 0], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x00,0x56,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55600 <unknown>
+
+sdot    za.d[w8, 0, vgx4], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11580 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11580 <unknown>
+
+sdot    za.d[w10, 1, vgx4], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xf9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f95401 <unknown>
+
+sdot    za.d[w10, 1], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xf9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f95401 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x85,0x16,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1685 <unknown>
+
+sdot    za.d[w8, 5], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x85,0x16,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1685 <unknown>
+
+sdot    za.d[w11, 2, vgx4], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x02,0x75,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e17502 <unknown>
+
+sdot    za.d[w11, 2], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x02,0x75,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e17502 <unknown>
+
+sdot    za.d[w9, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e93587 <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e93587 <unknown>
+

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

 // RUN: llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2,+sme-i64 < %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,+sme-i64 < %s \
 // RUN:        | llvm-objdump -d --mattr=+sme2,+sme-i64 - | FileCheck %s --check-prefix=CHECK-INST
 // RUN: llvm-mc -triple=aarch64 -filetype=obj -mattr=+sme2,+sme-i64 < %s \
 // RUN:        | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
 // RUN: llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2,+sme-i64 < %s \
 // RUN:        | sed '/.text/d' | sed 's/.*encoding: //g' \
 // RUN:        | llvm-mc -triple=aarch64 -mattr=+sme2,+sme-i64 -disassemble -show-encoding \
 // RUN:        | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
 
 
-udot    za.s[w8, 0, vgx2], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h
-// CHECK-ENCODING: [0x18,0x14,0x60,0xc1]
+sdot    za.s[w8, 0, vgx2], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h
+// CHECK-ENCODING: [0x08,0x14,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1601418 <unknown>
+// CHECK-UNKNOWN: c1601408 <unknown>
 
-udot    za.s[w8, 0], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h
-// CHECK-ENCODING: [0x18,0x14,0x60,0xc1]
+sdot    za.s[w8, 0], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h
+// CHECK-ENCODING: [0x08,0x14,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1601418 <unknown>
+// CHECK-UNKNOWN: c1601408 <unknown>
 
-udot    za.s[w10, 5, vgx2], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01011101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h
-// CHECK-ENCODING: [0x5d,0x55,0x65,0xc1]
+sdot    za.s[w10, 5, vgx2], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h
+// CHECK-ENCODING: [0x4d,0x55,0x65,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c165555d <unknown>
+// CHECK-UNKNOWN: c165554d <unknown>
 
-udot    za.s[w10, 5], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01011101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h
-// CHECK-ENCODING: [0x5d,0x55,0x65,0xc1]
+sdot    za.s[w10, 5], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h
+// CHECK-ENCODING: [0x4d,0x55,0x65,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c165555d <unknown>
+// CHECK-UNKNOWN: c165554d <unknown>
 
-udot    za.s[w11, 7, vgx2], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10111111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z13.h-z14.h }, z8.h
-// CHECK-ENCODING: [0xbf,0x75,0x68,0xc1]
+sdot    za.s[w11, 7, vgx2], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z13.h-z14.h }, z8.h
+// CHECK-ENCODING: [0xaf,0x75,0x68,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16875bf <unknown>
+// CHECK-UNKNOWN: c16875af <unknown>
 
-udot    za.s[w11, 7], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10111111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z13.h-z14.h }, z8.h
-// CHECK-ENCODING: [0xbf,0x75,0x68,0xc1]
+sdot    za.s[w11, 7], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z13.h-z14.h }, z8.h
+// CHECK-ENCODING: [0xaf,0x75,0x68,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16875bf <unknown>
+// CHECK-UNKNOWN: c16875af <unknown>
 
-udot    za.s[w11, 7, vgx2], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11111111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z31.h-z0.h }, z15.h
-// CHECK-ENCODING: [0xff,0x77,0x6f,0xc1]
+sdot    za.s[w11, 7, vgx2], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z31.h-z0.h }, z15.h
+// CHECK-ENCODING: [0xef,0x77,0x6f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16f77ff <unknown>
+// CHECK-UNKNOWN: c16f77ef <unknown>
 
-udot    za.s[w11, 7], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11111111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z31.h-z0.h }, z15.h
-// CHECK-ENCODING: [0xff,0x77,0x6f,0xc1]
+sdot    za.s[w11, 7], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z31.h-z0.h }, z15.h
+// CHECK-ENCODING: [0xef,0x77,0x6f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16f77ff <unknown>
+// CHECK-UNKNOWN: c16f77ef <unknown>
 
-udot    za.s[w8, 5, vgx2], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00111101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z17.h-z18.h }, z0.h
-// CHECK-ENCODING: [0x3d,0x16,0x60,0xc1]
+sdot    za.s[w8, 5, vgx2], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00101101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z17.h-z18.h }, z0.h
+// CHECK-ENCODING: [0x2d,0x16,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c160163d <unknown>
+// CHECK-UNKNOWN: c160162d <unknown>
 
-udot    za.s[w8, 5], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00111101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z17.h-z18.h }, z0.h
-// CHECK-ENCODING: [0x3d,0x16,0x60,0xc1]
+sdot    za.s[w8, 5], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00101101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z17.h-z18.h }, z0.h
+// CHECK-ENCODING: [0x2d,0x16,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c160163d <unknown>
+// CHECK-UNKNOWN: c160162d <unknown>
 
-udot    za.s[w8, 1, vgx2], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00111001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z1.h-z2.h }, z14.h
-// CHECK-ENCODING: [0x39,0x14,0x6e,0xc1]
+sdot    za.s[w8, 1, vgx2], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00101001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z1.h-z2.h }, z14.h
+// CHECK-ENCODING: [0x29,0x14,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16e1439 <unknown>
+// CHECK-UNKNOWN: c16e1429 <unknown>
 
-udot    za.s[w8, 1], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00111001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z1.h-z2.h }, z14.h
-// CHECK-ENCODING: [0x39,0x14,0x6e,0xc1]
+sdot    za.s[w8, 1], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00101001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z1.h-z2.h }, z14.h
+// CHECK-ENCODING: [0x29,0x14,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16e1439 <unknown>
+// CHECK-UNKNOWN: c16e1429 <unknown>
 
-udot    za.s[w10, 0, vgx2], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01111000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z19.h-z20.h }, z4.h
-// CHECK-ENCODING: [0x78,0x56,0x64,0xc1]
+sdot    za.s[w10, 0, vgx2], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01101000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z19.h-z20.h }, z4.h
+// CHECK-ENCODING: [0x68,0x56,0x64,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1645678 <unknown>
+// CHECK-UNKNOWN: c1645668 <unknown>
 
-udot    za.s[w10, 0], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01111000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z19.h-z20.h }, z4.h
-// CHECK-ENCODING: [0x78,0x56,0x64,0xc1]
+sdot    za.s[w10, 0], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01101000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z19.h-z20.h }, z4.h
+// CHECK-ENCODING: [0x68,0x56,0x64,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1645678 <unknown>
+// CHECK-UNKNOWN: c1645668 <unknown>
 
-udot    za.s[w8, 0, vgx2], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h
-// CHECK-ENCODING: [0x98,0x15,0x62,0xc1]
+sdot    za.s[w8, 0, vgx2], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h
+// CHECK-ENCODING: [0x88,0x15,0x62,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1621598 <unknown>
+// CHECK-UNKNOWN: c1621588 <unknown>
 
-udot    za.s[w8, 0], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h
-// CHECK-ENCODING: [0x98,0x15,0x62,0xc1]
+sdot    za.s[w8, 0], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h
+// CHECK-ENCODING: [0x88,0x15,0x62,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1621598 <unknown>
+// CHECK-UNKNOWN: c1621588 <unknown>
 
-udot    za.s[w10, 1, vgx2], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00111001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z1.h-z2.h }, z10.h
-// CHECK-ENCODING: [0x39,0x54,0x6a,0xc1]
+sdot    za.s[w10, 1, vgx2], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00101001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z1.h-z2.h }, z10.h
+// CHECK-ENCODING: [0x29,0x54,0x6a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16a5439 <unknown>
+// CHECK-UNKNOWN: c16a5429 <unknown>
 
-udot    za.s[w10, 1], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00111001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z1.h-z2.h }, z10.h
-// CHECK-ENCODING: [0x39,0x54,0x6a,0xc1]
+sdot    za.s[w10, 1], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00101001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z1.h-z2.h }, z10.h
+// CHECK-ENCODING: [0x29,0x54,0x6a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16a5439 <unknown>
+// CHECK-UNKNOWN: c16a5429 <unknown>
 
-udot    za.s[w8, 5, vgx2], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11011101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h
-// CHECK-ENCODING: [0xdd,0x16,0x6e,0xc1]
+sdot    za.s[w8, 5, vgx2], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h
+// CHECK-ENCODING: [0xcd,0x16,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16e16dd <unknown>
+// CHECK-UNKNOWN: c16e16cd <unknown>
 
-udot    za.s[w8, 5], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11011101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h
-// CHECK-ENCODING: [0xdd,0x16,0x6e,0xc1]
+sdot    za.s[w8, 5], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h
+// CHECK-ENCODING: [0xcd,0x16,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16e16dd <unknown>
+// CHECK-UNKNOWN: c16e16cd <unknown>
 
-udot    za.s[w11, 2, vgx2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00111010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z9.h-z10.h }, z1.h
-// CHECK-ENCODING: [0x3a,0x75,0x61,0xc1]
+sdot    za.s[w11, 2, vgx2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00101010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z9.h-z10.h }, z1.h
+// CHECK-ENCODING: [0x2a,0x75,0x61,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c161753a <unknown>
+// CHECK-UNKNOWN: c161752a <unknown>
 
-udot    za.s[w11, 2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00111010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z9.h-z10.h }, z1.h
-// CHECK-ENCODING: [0x3a,0x75,0x61,0xc1]
+sdot    za.s[w11, 2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00101010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z9.h-z10.h }, z1.h
+// CHECK-ENCODING: [0x2a,0x75,0x61,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c161753a <unknown>
+// CHECK-UNKNOWN: c161752a <unknown>
 
-udot    za.s[w9, 7, vgx2], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h
-// CHECK-ENCODING: [0x9f,0x35,0x6b,0xc1]
+sdot    za.s[w9, 7, vgx2], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h
+// CHECK-ENCODING: [0x8f,0x35,0x6b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16b359f <unknown>
+// CHECK-UNKNOWN: c16b358f <unknown>
 
-udot    za.s[w9, 7], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h
-// CHECK-ENCODING: [0x9f,0x35,0x6b,0xc1]
+sdot    za.s[w9, 7], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h
+// CHECK-ENCODING: [0x8f,0x35,0x6b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c16b359f <unknown>
+// CHECK-UNKNOWN: c16b358f <unknown>
 
 
-udot    za.s[w8, 0, vgx2], {z0.h-z1.h}, z0.h[0]  // 11000001-01010000-00010000-00010000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
-// CHECK-ENCODING: [0x10,0x10,0x50,0xc1]
+sdot    za.s[w8, 0, vgx2], {z0.h-z1.h}, z0.h[0]  // 11000001-01010000-00010000-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
+// CHECK-ENCODING: [0x00,0x10,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501010 <unknown>
+// CHECK-UNKNOWN: c1501000 <unknown>
 
-udot    za.s[w8, 0], {z0.h-z1.h}, z0.h[0]  // 11000001-01010000-00010000-00010000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
-// CHECK-ENCODING: [0x10,0x10,0x50,0xc1]
+sdot    za.s[w8, 0], {z0.h-z1.h}, z0.h[0]  // 11000001-01010000-00010000-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
+// CHECK-ENCODING: [0x00,0x10,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501010 <unknown>
+// CHECK-UNKNOWN: c1501000 <unknown>
 
-udot    za.s[w10, 5, vgx2], {z10.h-z11.h}, z5.h[1]  // 11000001-01010101-01010101-01010101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x55,0x55,0x55,0xc1]
+sdot    za.s[w10, 5, vgx2], {z10.h-z11.h}, z5.h[1]  // 11000001-01010101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x45,0x55,0x55,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1555555 <unknown>
+// CHECK-UNKNOWN: c1555545 <unknown>
 
-udot    za.s[w10, 5], {z10.h-z11.h}, z5.h[1]  // 11000001-01010101-01010101-01010101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x55,0x55,0x55,0xc1]
+sdot    za.s[w10, 5], {z10.h-z11.h}, z5.h[1]  // 11000001-01010101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x45,0x55,0x55,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1555555 <unknown>
+// CHECK-UNKNOWN: c1555545 <unknown>
 
-udot    za.s[w11, 7, vgx2], {z12.h-z13.h}, z8.h[3]  // 11000001-01011000-01111101-10010111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z12.h-z13.h }, z8.h[3]
-// CHECK-ENCODING: [0x97,0x7d,0x58,0xc1]
+sdot    za.s[w11, 7, vgx2], {z12.h-z13.h}, z8.h[3]  // 11000001-01011000-01111101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.h-z13.h }, z8.h[3]
+// CHECK-ENCODING: [0x87,0x7d,0x58,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1587d97 <unknown>
+// CHECK-UNKNOWN: c1587d87 <unknown>
 
-udot    za.s[w11, 7], {z12.h-z13.h}, z8.h[3]  // 11000001-01011000-01111101-10010111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z12.h-z13.h }, z8.h[3]
-// CHECK-ENCODING: [0x97,0x7d,0x58,0xc1]
+sdot    za.s[w11, 7], {z12.h-z13.h}, z8.h[3]  // 11000001-01011000-01111101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.h-z13.h }, z8.h[3]
+// CHECK-ENCODING: [0x87,0x7d,0x58,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1587d97 <unknown>
+// CHECK-UNKNOWN: c1587d87 <unknown>
 
-udot    za.s[w11, 7, vgx2], {z30.h-z31.h}, z15.h[3]  // 11000001-01011111-01111111-11010111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z30.h-z31.h }, z15.h[3]
-// CHECK-ENCODING: [0xd7,0x7f,0x5f,0xc1]
+sdot    za.s[w11, 7, vgx2], {z30.h-z31.h}, z15.h[3]  // 11000001-01011111-01111111-11000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.h-z31.h }, z15.h[3]
+// CHECK-ENCODING: [0xc7,0x7f,0x5f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15f7fd7 <unknown>
+// CHECK-UNKNOWN: c15f7fc7 <unknown>
 
-udot    za.s[w11, 7], {z30.h-z31.h}, z15.h[3]  // 11000001-01011111-01111111-11010111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z30.h-z31.h }, z15.h[3]
-// CHECK-ENCODING: [0xd7,0x7f,0x5f,0xc1]
+sdot    za.s[w11, 7], {z30.h-z31.h}, z15.h[3]  // 11000001-01011111-01111111-11000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.h-z31.h }, z15.h[3]
+// CHECK-ENCODING: [0xc7,0x7f,0x5f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15f7fd7 <unknown>
+// CHECK-UNKNOWN: c15f7fc7 <unknown>
 
-udot    za.s[w8, 5, vgx2], {z16.h-z17.h}, z0.h[3]  // 11000001-01010000-00011110-00010101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z16.h-z17.h }, z0.h[3]
-// CHECK-ENCODING: [0x15,0x1e,0x50,0xc1]
+sdot    za.s[w8, 5, vgx2], {z16.h-z17.h}, z0.h[3]  // 11000001-01010000-00011110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.h-z17.h }, z0.h[3]
+// CHECK-ENCODING: [0x05,0x1e,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501e15 <unknown>
+// CHECK-UNKNOWN: c1501e05 <unknown>
 
-udot    za.s[w8, 5], {z16.h-z17.h}, z0.h[3]  // 11000001-01010000-00011110-00010101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z16.h-z17.h }, z0.h[3]
-// CHECK-ENCODING: [0x15,0x1e,0x50,0xc1]
+sdot    za.s[w8, 5], {z16.h-z17.h}, z0.h[3]  // 11000001-01010000-00011110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.h-z17.h }, z0.h[3]
+// CHECK-ENCODING: [0x05,0x1e,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501e15 <unknown>
+// CHECK-UNKNOWN: c1501e05 <unknown>
 
-udot    za.s[w8, 1, vgx2], {z0.h-z1.h}, z14.h[1]  // 11000001-01011110-00010100-00010001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
-// CHECK-ENCODING: [0x11,0x14,0x5e,0xc1]
+sdot    za.s[w8, 1, vgx2], {z0.h-z1.h}, z14.h[1]  // 11000001-01011110-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
+// CHECK-ENCODING: [0x01,0x14,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1411 <unknown>
+// CHECK-UNKNOWN: c15e1401 <unknown>
 
-udot    za.s[w8, 1], {z0.h-z1.h}, z14.h[1]  // 11000001-01011110-00010100-00010001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
-// CHECK-ENCODING: [0x11,0x14,0x5e,0xc1]
+sdot    za.s[w8, 1], {z0.h-z1.h}, z14.h[1]  // 11000001-01011110-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
+// CHECK-ENCODING: [0x01,0x14,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1411 <unknown>
+// CHECK-UNKNOWN: c15e1401 <unknown>
 
-udot    za.s[w10, 0, vgx2], {z18.h-z19.h}, z4.h[1]  // 11000001-01010100-01010110-01010000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x50,0x56,0x54,0xc1]
+sdot    za.s[w10, 0, vgx2], {z18.h-z19.h}, z4.h[1]  // 11000001-01010100-01010110-01000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x40,0x56,0x54,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1545650 <unknown>
+// CHECK-UNKNOWN: c1545640 <unknown>
 
-udot    za.s[w10, 0], {z18.h-z19.h}, z4.h[1]  // 11000001-01010100-01010110-01010000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x50,0x56,0x54,0xc1]
+sdot    za.s[w10, 0], {z18.h-z19.h}, z4.h[1]  // 11000001-01010100-01010110-01000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x40,0x56,0x54,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1545650 <unknown>
+// CHECK-UNKNOWN: c1545640 <unknown>
 
-udot    za.s[w8, 0, vgx2], {z12.h-z13.h}, z2.h[2]  // 11000001-01010010-00011001-10010000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h[2]
-// CHECK-ENCODING: [0x90,0x19,0x52,0xc1]
+sdot    za.s[w8, 0, vgx2], {z12.h-z13.h}, z2.h[2]  // 11000001-01010010-00011001-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h[2]
+// CHECK-ENCODING: [0x80,0x19,0x52,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1521990 <unknown>
+// CHECK-UNKNOWN: c1521980 <unknown>
 
-udot    za.s[w8, 0], {z12.h-z13.h}, z2.h[2]  // 11000001-01010010-00011001-10010000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h[2]
-// CHECK-ENCODING: [0x90,0x19,0x52,0xc1]
+sdot    za.s[w8, 0], {z12.h-z13.h}, z2.h[2]  // 11000001-01010010-00011001-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.h-z13.h }, z2.h[2]
+// CHECK-ENCODING: [0x80,0x19,0x52,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1521990 <unknown>
+// CHECK-UNKNOWN: c1521980 <unknown>
 
-udot    za.s[w10, 1, vgx2], {z0.h-z1.h}, z10.h[2]  // 11000001-01011010-01011000-00010001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z0.h-z1.h }, z10.h[2]
-// CHECK-ENCODING: [0x11,0x58,0x5a,0xc1]
+sdot    za.s[w10, 1, vgx2], {z0.h-z1.h}, z10.h[2]  // 11000001-01011010-01011000-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.h-z1.h }, z10.h[2]
+// CHECK-ENCODING: [0x01,0x58,0x5a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15a5811 <unknown>
+// CHECK-UNKNOWN: c15a5801 <unknown>
 
-udot    za.s[w10, 1], {z0.h-z1.h}, z10.h[2]  // 11000001-01011010-01011000-00010001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z0.h-z1.h }, z10.h[2]
-// CHECK-ENCODING: [0x11,0x58,0x5a,0xc1]
+sdot    za.s[w10, 1], {z0.h-z1.h}, z10.h[2]  // 11000001-01011010-01011000-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.h-z1.h }, z10.h[2]
+// CHECK-ENCODING: [0x01,0x58,0x5a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15a5811 <unknown>
+// CHECK-UNKNOWN: c15a5801 <unknown>
 
-udot    za.s[w8, 5, vgx2], {z22.h-z23.h}, z14.h[2]  // 11000001-01011110-00011010-11010101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h[2]
-// CHECK-ENCODING: [0xd5,0x1a,0x5e,0xc1]
+sdot    za.s[w8, 5, vgx2], {z22.h-z23.h}, z14.h[2]  // 11000001-01011110-00011010-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h[2]
+// CHECK-ENCODING: [0xc5,0x1a,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1ad5 <unknown>
+// CHECK-UNKNOWN: c15e1ac5 <unknown>
 
-udot    za.s[w8, 5], {z22.h-z23.h}, z14.h[2]  // 11000001-01011110-00011010-11010101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h[2]
-// CHECK-ENCODING: [0xd5,0x1a,0x5e,0xc1]
+sdot    za.s[w8, 5], {z22.h-z23.h}, z14.h[2]  // 11000001-01011110-00011010-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.h-z23.h }, z14.h[2]
+// CHECK-ENCODING: [0xc5,0x1a,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1ad5 <unknown>
+// CHECK-UNKNOWN: c15e1ac5 <unknown>
 
-udot    za.s[w11, 2, vgx2], {z8.h-z9.h}, z1.h[1]  // 11000001-01010001-01110101-00010010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
-// CHECK-ENCODING: [0x12,0x75,0x51,0xc1]
+sdot    za.s[w11, 2, vgx2], {z8.h-z9.h}, z1.h[1]  // 11000001-01010001-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
+// CHECK-ENCODING: [0x02,0x75,0x51,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1517512 <unknown>
+// CHECK-UNKNOWN: c1517502 <unknown>
 
-udot    za.s[w11, 2], {z8.h-z9.h}, z1.h[1]  // 11000001-01010001-01110101-00010010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
-// CHECK-ENCODING: [0x12,0x75,0x51,0xc1]
+sdot    za.s[w11, 2], {z8.h-z9.h}, z1.h[1]  // 11000001-01010001-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
+// CHECK-ENCODING: [0x02,0x75,0x51,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1517512 <unknown>
+// CHECK-UNKNOWN: c1517502 <unknown>
 
-udot    za.s[w9, 7, vgx2], {z12.h-z13.h}, z11.h[2]  // 11000001-01011011-00111001-10010111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h[2]
-// CHECK-ENCODING: [0x97,0x39,0x5b,0xc1]
+sdot    za.s[w9, 7, vgx2], {z12.h-z13.h}, z11.h[2]  // 11000001-01011011-00111001-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h[2]
+// CHECK-ENCODING: [0x87,0x39,0x5b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15b3997 <unknown>
+// CHECK-UNKNOWN: c15b3987 <unknown>
 
-udot    za.s[w9, 7], {z12.h-z13.h}, z11.h[2]  // 11000001-01011011-00111001-10010111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h[2]
-// CHECK-ENCODING: [0x97,0x39,0x5b,0xc1]
+sdot    za.s[w9, 7], {z12.h-z13.h}, z11.h[2]  // 11000001-01011011-00111001-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, z11.h[2]
+// CHECK-ENCODING: [0x87,0x39,0x5b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15b3997 <unknown>
+// CHECK-UNKNOWN: c15b3987 <unknown>
 
 
-udot    za.s[w8, 0, vgx2], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
-// CHECK-ENCODING: [0x18,0x14,0xe0,0xc1]
+sdot    za.s[w8, 0, vgx2], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x08,0x14,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e01418 <unknown>
+// CHECK-UNKNOWN: c1e01408 <unknown>
 
-udot    za.s[w8, 0], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
-// CHECK-ENCODING: [0x18,0x14,0xe0,0xc1]
+sdot    za.s[w8, 0], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x08,0x14,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e01418 <unknown>
+// CHECK-UNKNOWN: c1e01408 <unknown>
 
-udot    za.s[w10, 5, vgx2], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01011101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
-// CHECK-ENCODING: [0x5d,0x55,0xf4,0xc1]
+sdot    za.s[w10, 5, vgx2], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x4d,0x55,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f4555d <unknown>
+// CHECK-UNKNOWN: c1f4554d <unknown>
 
-udot    za.s[w10, 5], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01011101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
-// CHECK-ENCODING: [0x5d,0x55,0xf4,0xc1]
+sdot    za.s[w10, 5], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x4d,0x55,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f4555d <unknown>
+// CHECK-UNKNOWN: c1f4554d <unknown>
 
-udot    za.s[w11, 7, vgx2], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10011111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
-// CHECK-ENCODING: [0x9f,0x75,0xe8,0xc1]
+sdot    za.s[w11, 7, vgx2], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
+// CHECK-ENCODING: [0x8f,0x75,0xe8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e8759f <unknown>
+// CHECK-UNKNOWN: c1e8758f <unknown>
 
-udot    za.s[w11, 7], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10011111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
-// CHECK-ENCODING: [0x9f,0x75,0xe8,0xc1]
+sdot    za.s[w11, 7], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
+// CHECK-ENCODING: [0x8f,0x75,0xe8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e8759f <unknown>
+// CHECK-UNKNOWN: c1e8758f <unknown>
 
-udot    za.s[w11, 7, vgx2], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11011111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
-// CHECK-ENCODING: [0xdf,0x77,0xfe,0xc1]
+sdot    za.s[w11, 7, vgx2], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xcf,0x77,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fe77df <unknown>
+// CHECK-UNKNOWN: c1fe77cf <unknown>
 
-udot    za.s[w11, 7], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11011111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
-// CHECK-ENCODING: [0xdf,0x77,0xfe,0xc1]
+sdot    za.s[w11, 7], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xcf,0x77,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fe77df <unknown>
+// CHECK-UNKNOWN: c1fe77cf <unknown>
 
-udot    za.s[w8, 5, vgx2], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00011101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
-// CHECK-ENCODING: [0x1d,0x16,0xf0,0xc1]
+sdot    za.s[w8, 5, vgx2], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
+// CHECK-ENCODING: [0x0d,0x16,0xf0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f0161d <unknown>
+// CHECK-UNKNOWN: c1f0160d <unknown>
 
-udot    za.s[w8, 5], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00011101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
-// CHECK-ENCODING: [0x1d,0x16,0xf0,0xc1]
+sdot    za.s[w8, 5], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
+// CHECK-ENCODING: [0x0d,0x16,0xf0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f0161d <unknown>
+// CHECK-UNKNOWN: c1f0160d <unknown>
 
-udot    za.s[w8, 1, vgx2], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00011001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
-// CHECK-ENCODING: [0x19,0x14,0xfe,0xc1]
+sdot    za.s[w8, 1, vgx2], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00001001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0x09,0x14,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fe1419 <unknown>
+// CHECK-UNKNOWN: c1fe1409 <unknown>
 
-udot    za.s[w8, 1], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00011001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
-// CHECK-ENCODING: [0x19,0x14,0xfe,0xc1]
+sdot    za.s[w8, 1], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00001001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0x09,0x14,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fe1419 <unknown>
+// CHECK-UNKNOWN: c1fe1409 <unknown>
 
-udot    za.s[w10, 0, vgx2], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01011000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
-// CHECK-ENCODING: [0x58,0x56,0xf4,0xc1]
+sdot    za.s[w10, 0, vgx2], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01001000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x48,0x56,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f45658 <unknown>
+// CHECK-UNKNOWN: c1f45648 <unknown>
 
-udot    za.s[w10, 0], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01011000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
-// CHECK-ENCODING: [0x58,0x56,0xf4,0xc1]
+sdot    za.s[w10, 0], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01001000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x48,0x56,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f45658 <unknown>
+// CHECK-UNKNOWN: c1f45648 <unknown>
 
-udot    za.s[w8, 0, vgx2], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
-// CHECK-ENCODING: [0x98,0x15,0xe2,0xc1]
+sdot    za.s[w8, 0, vgx2], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
+// CHECK-ENCODING: [0x88,0x15,0xe2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e21598 <unknown>
+// CHECK-UNKNOWN: c1e21588 <unknown>
 
-udot    za.s[w8, 0], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
-// CHECK-ENCODING: [0x98,0x15,0xe2,0xc1]
+sdot    za.s[w8, 0], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
+// CHECK-ENCODING: [0x88,0x15,0xe2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e21598 <unknown>
+// CHECK-UNKNOWN: c1e21588 <unknown>
 
-udot    za.s[w10, 1, vgx2], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00011001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
-// CHECK-ENCODING: [0x19,0x54,0xfa,0xc1]
+sdot    za.s[w10, 1, vgx2], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00001001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
+// CHECK-ENCODING: [0x09,0x54,0xfa,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fa5419 <unknown>
+// CHECK-UNKNOWN: c1fa5409 <unknown>
 
-udot    za.s[w10, 1], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00011001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
-// CHECK-ENCODING: [0x19,0x54,0xfa,0xc1]
+sdot    za.s[w10, 1], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00001001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
+// CHECK-ENCODING: [0x09,0x54,0xfa,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fa5419 <unknown>
+// CHECK-UNKNOWN: c1fa5409 <unknown>
 
-udot    za.s[w8, 5, vgx2], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11011101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
-// CHECK-ENCODING: [0xdd,0x16,0xfe,0xc1]
+sdot    za.s[w8, 5, vgx2], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xcd,0x16,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fe16dd <unknown>
+// CHECK-UNKNOWN: c1fe16cd <unknown>
 
-udot    za.s[w8, 5], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11011101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
-// CHECK-ENCODING: [0xdd,0x16,0xfe,0xc1]
+sdot    za.s[w8, 5], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xcd,0x16,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fe16dd <unknown>
+// CHECK-UNKNOWN: c1fe16cd <unknown>
 
-udot    za.s[w11, 2, vgx2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00011010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
-// CHECK-ENCODING: [0x1a,0x75,0xe0,0xc1]
+sdot    za.s[w11, 2, vgx2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00001010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x0a,0x75,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e0751a <unknown>
+// CHECK-UNKNOWN: c1e0750a <unknown>
 
-udot    za.s[w11, 2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00011010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
-// CHECK-ENCODING: [0x1a,0x75,0xe0,0xc1]
+sdot    za.s[w11, 2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00001010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x0a,0x75,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e0751a <unknown>
+// CHECK-UNKNOWN: c1e0750a <unknown>
 
-udot    za.s[w9, 7, vgx2], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
-// CHECK-ENCODING: [0x9f,0x35,0xea,0xc1]
+sdot    za.s[w9, 7, vgx2], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
+// CHECK-ENCODING: [0x8f,0x35,0xea,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1ea359f <unknown>
+// CHECK-UNKNOWN: c1ea358f <unknown>
 
-udot    za.s[w9, 7], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
-// CHECK-ENCODING: [0x9f,0x35,0xea,0xc1]
+sdot    za.s[w9, 7], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
+// CHECK-ENCODING: [0x8f,0x35,0xea,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1ea359f <unknown>
+// CHECK-UNKNOWN: c1ea358f <unknown>
 
 
-udot    za.s[w8, 0, vgx2], {z0.b-z1.b}, z0.b[0]  // 11000001-01010000-00010000-00110000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b[0]
-// CHECK-ENCODING: [0x30,0x10,0x50,0xc1]
+sdot    za.s[w8, 0, vgx2], {z0.b-z1.b}, z0.b  // 11000001-00100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x20,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501030 <unknown>
+// CHECK-UNKNOWN: c1201400 <unknown>
 
-udot    za.s[w8, 0], {z0.b-z1.b}, z0.b[0]  // 11000001-01010000-00010000-00110000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b[0]
-// CHECK-ENCODING: [0x30,0x10,0x50,0xc1]
+sdot    za.s[w8, 0], {z0.b-z1.b}, z0.b  // 11000001-00100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x20,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501030 <unknown>
+// CHECK-UNKNOWN: c1201400 <unknown>
 
-udot    za.s[w10, 5, vgx2], {z10.b-z11.b}, z5.b[1]  // 11000001-01010101-01010101-01110101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b[1]
-// CHECK-ENCODING: [0x75,0x55,0x55,0xc1]
+sdot    za.s[w10, 5, vgx2], {z10.b-z11.b}, z5.b  // 11000001-00100101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x25,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1555575 <unknown>
+// CHECK-UNKNOWN: c1255545 <unknown>
 
-udot    za.s[w10, 5], {z10.b-z11.b}, z5.b[1]  // 11000001-01010101-01010101-01110101
-// CHECK-INST: udot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b[1]
-// CHECK-ENCODING: [0x75,0x55,0x55,0xc1]
+sdot    za.s[w10, 5], {z10.b-z11.b}, z5.b  // 11000001-00100101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x25,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1555575 <unknown>
+// CHECK-UNKNOWN: c1255545 <unknown>
 
-udot    za.s[w11, 7, vgx2], {z12.b-z13.b}, z8.b[3]  // 11000001-01011000-01111101-10110111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z12.b-z13.b }, z8.b[3]
-// CHECK-ENCODING: [0xb7,0x7d,0x58,0xc1]
+sdot    za.s[w11, 7, vgx2], {z13.b-z14.b}, z8.b  // 11000001-00101000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z13.b-z14.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x28,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1587db7 <unknown>
+// CHECK-UNKNOWN: c12875a7 <unknown>
 
-udot    za.s[w11, 7], {z12.b-z13.b}, z8.b[3]  // 11000001-01011000-01111101-10110111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z12.b-z13.b }, z8.b[3]
-// CHECK-ENCODING: [0xb7,0x7d,0x58,0xc1]
+sdot    za.s[w11, 7], {z13.b-z14.b}, z8.b  // 11000001-00101000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z13.b-z14.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x28,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1587db7 <unknown>
+// CHECK-UNKNOWN: c12875a7 <unknown>
 
-udot    za.s[w11, 7, vgx2], {z30.b-z31.b}, z15.b[3]  // 11000001-01011111-01111111-11110111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z30.b-z31.b }, z15.b[3]
-// CHECK-ENCODING: [0xf7,0x7f,0x5f,0xc1]
+sdot    za.s[w11, 7, vgx2], {z31.b-z0.b}, z15.b  // 11000001-00101111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z31.b-z0.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x2f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15f7ff7 <unknown>
+// CHECK-UNKNOWN: c12f77e7 <unknown>
 
-udot    za.s[w11, 7], {z30.b-z31.b}, z15.b[3]  // 11000001-01011111-01111111-11110111
-// CHECK-INST: udot    za.s[w11, 7, vgx2], { z30.b-z31.b }, z15.b[3]
-// CHECK-ENCODING: [0xf7,0x7f,0x5f,0xc1]
+sdot    za.s[w11, 7], {z31.b-z0.b}, z15.b  // 11000001-00101111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z31.b-z0.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x2f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15f7ff7 <unknown>
+// CHECK-UNKNOWN: c12f77e7 <unknown>
 
-udot    za.s[w8, 5, vgx2], {z16.b-z17.b}, z0.b[3]  // 11000001-01010000-00011110-00110101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z16.b-z17.b }, z0.b[3]
-// CHECK-ENCODING: [0x35,0x1e,0x50,0xc1]
+sdot    za.s[w8, 5, vgx2], {z17.b-z18.b}, z0.b  // 11000001-00100000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z17.b-z18.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x20,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501e35 <unknown>
+// CHECK-UNKNOWN: c1201625 <unknown>
 
-udot    za.s[w8, 5], {z16.b-z17.b}, z0.b[3]  // 11000001-01010000-00011110-00110101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z16.b-z17.b }, z0.b[3]
-// CHECK-ENCODING: [0x35,0x1e,0x50,0xc1]
+sdot    za.s[w8, 5], {z17.b-z18.b}, z0.b  // 11000001-00100000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z17.b-z18.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x20,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1501e35 <unknown>
+// CHECK-UNKNOWN: c1201625 <unknown>
 
-udot    za.s[w8, 1, vgx2], {z0.b-z1.b}, z14.b[1]  // 11000001-01011110-00010100-00110001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z0.b-z1.b }, z14.b[1]
-// CHECK-ENCODING: [0x31,0x14,0x5e,0xc1]
+sdot    za.s[w8, 1, vgx2], {z1.b-z2.b}, z14.b  // 11000001-00101110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z1.b-z2.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x2e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1431 <unknown>
+// CHECK-UNKNOWN: c12e1421 <unknown>
 
-udot    za.s[w8, 1], {z0.b-z1.b}, z14.b[1]  // 11000001-01011110-00010100-00110001
-// CHECK-INST: udot    za.s[w8, 1, vgx2], { z0.b-z1.b }, z14.b[1]
-// CHECK-ENCODING: [0x31,0x14,0x5e,0xc1]
+sdot    za.s[w8, 1], {z1.b-z2.b}, z14.b  // 11000001-00101110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z1.b-z2.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x2e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1431 <unknown>
+// CHECK-UNKNOWN: c12e1421 <unknown>
 
-udot    za.s[w10, 0, vgx2], {z18.b-z19.b}, z4.b[1]  // 11000001-01010100-01010110-01110000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z18.b-z19.b }, z4.b[1]
-// CHECK-ENCODING: [0x70,0x56,0x54,0xc1]
+sdot    za.s[w10, 0, vgx2], {z19.b-z20.b}, z4.b  // 11000001-00100100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z19.b-z20.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x24,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1545670 <unknown>
+// CHECK-UNKNOWN: c1245660 <unknown>
 
-udot    za.s[w10, 0], {z18.b-z19.b}, z4.b[1]  // 11000001-01010100-01010110-01110000
-// CHECK-INST: udot    za.s[w10, 0, vgx2], { z18.b-z19.b }, z4.b[1]
-// CHECK-ENCODING: [0x70,0x56,0x54,0xc1]
+sdot    za.s[w10, 0], {z19.b-z20.b}, z4.b  // 11000001-00100100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z19.b-z20.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x24,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1545670 <unknown>
+// CHECK-UNKNOWN: c1245660 <unknown>
 
-udot    za.s[w8, 0, vgx2], {z12.b-z13.b}, z2.b[2]  // 11000001-01010010-00011001-10110000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b[2]
-// CHECK-ENCODING: [0xb0,0x19,0x52,0xc1]
+sdot    za.s[w8, 0, vgx2], {z12.b-z13.b}, z2.b  // 11000001-00100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x22,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15219b0 <unknown>
+// CHECK-UNKNOWN: c1221580 <unknown>
 
-udot    za.s[w8, 0], {z12.b-z13.b}, z2.b[2]  // 11000001-01010010-00011001-10110000
-// CHECK-INST: udot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b[2]
-// CHECK-ENCODING: [0xb0,0x19,0x52,0xc1]
+sdot    za.s[w8, 0], {z12.b-z13.b}, z2.b  // 11000001-00100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x22,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15219b0 <unknown>
+// CHECK-UNKNOWN: c1221580 <unknown>
 
-udot    za.s[w10, 1, vgx2], {z0.b-z1.b}, z10.b[2]  // 11000001-01011010-01011000-00110001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z0.b-z1.b }, z10.b[2]
-// CHECK-ENCODING: [0x31,0x58,0x5a,0xc1]
+sdot    za.s[w10, 1, vgx2], {z1.b-z2.b}, z10.b  // 11000001-00101010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z1.b-z2.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x2a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15a5831 <unknown>
+// CHECK-UNKNOWN: c12a5421 <unknown>
 
-udot    za.s[w10, 1], {z0.b-z1.b}, z10.b[2]  // 11000001-01011010-01011000-00110001
-// CHECK-INST: udot    za.s[w10, 1, vgx2], { z0.b-z1.b }, z10.b[2]
-// CHECK-ENCODING: [0x31,0x58,0x5a,0xc1]
+sdot    za.s[w10, 1], {z1.b-z2.b}, z10.b  // 11000001-00101010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z1.b-z2.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x2a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15a5831 <unknown>
+// CHECK-UNKNOWN: c12a5421 <unknown>
 
-udot    za.s[w8, 5, vgx2], {z22.b-z23.b}, z14.b[2]  // 11000001-01011110-00011010-11110101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b[2]
-// CHECK-ENCODING: [0xf5,0x1a,0x5e,0xc1]
+sdot    za.s[w8, 5, vgx2], {z22.b-z23.b}, z14.b  // 11000001-00101110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x2e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1af5 <unknown>
+// CHECK-UNKNOWN: c12e16c5 <unknown>
 
-udot    za.s[w8, 5], {z22.b-z23.b}, z14.b[2]  // 11000001-01011110-00011010-11110101
-// CHECK-INST: udot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b[2]
-// CHECK-ENCODING: [0xf5,0x1a,0x5e,0xc1]
+sdot    za.s[w8, 5], {z22.b-z23.b}, z14.b  // 11000001-00101110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x2e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e1af5 <unknown>
+// CHECK-UNKNOWN: c12e16c5 <unknown>
 
-udot    za.s[w11, 2, vgx2], {z8.b-z9.b}, z1.b[1]  // 11000001-01010001-01110101-00110010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z8.b-z9.b }, z1.b[1]
-// CHECK-ENCODING: [0x32,0x75,0x51,0xc1]
+sdot    za.s[w11, 2, vgx2], {z9.b-z10.b}, z1.b  // 11000001-00100001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z9.b-z10.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x21,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1517532 <unknown>
+// CHECK-UNKNOWN: c1217522 <unknown>
 
-udot    za.s[w11, 2], {z8.b-z9.b}, z1.b[1]  // 11000001-01010001-01110101-00110010
-// CHECK-INST: udot    za.s[w11, 2, vgx2], { z8.b-z9.b }, z1.b[1]
-// CHECK-ENCODING: [0x32,0x75,0x51,0xc1]
+sdot    za.s[w11, 2], {z9.b-z10.b}, z1.b  // 11000001-00100001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z9.b-z10.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x21,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1517532 <unknown>
+// CHECK-UNKNOWN: c1217522 <unknown>
 
-udot    za.s[w9, 7, vgx2], {z12.b-z13.b}, z11.b[2]  // 11000001-01011011-00111001-10110111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b[2]
-// CHECK-ENCODING: [0xb7,0x39,0x5b,0xc1]
+sdot    za.s[w9, 7, vgx2], {z12.b-z13.b}, z11.b  // 11000001-00101011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x2b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15b39b7 <unknown>
+// CHECK-UNKNOWN: c12b3587 <unknown>
 
-udot    za.s[w9, 7], {z12.b-z13.b}, z11.b[2]  // 11000001-01011011-00111001-10110111
-// CHECK-INST: udot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b[2]
-// CHECK-ENCODING: [0xb7,0x39,0x5b,0xc1]
+sdot    za.s[w9, 7], {z12.b-z13.b}, z11.b  // 11000001-00101011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x2b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15b39b7 <unknown>
+// CHECK-UNKNOWN: c12b3587 <unknown>
 
 
-udot    za.d[w8, 0, vgx2], {z0.h-z1.h}, z0.h[0]  // 11000001-11010000-00000000-00011000
-// CHECK-INST: udot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
-// CHECK-ENCODING: [0x18,0x00,0xd0,0xc1]
+sdot    za.s[w8, 0, vgx2], {z0.b-z1.b}, z0.b[0]  // 11000001-01010000-00010000-00100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b[0]
+// CHECK-ENCODING: [0x20,0x10,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d00018 <unknown>
+// CHECK-UNKNOWN: c1501020 <unknown>
 
-udot    za.d[w8, 0], {z0.h-z1.h}, z0.h[0]  // 11000001-11010000-00000000-00011000
-// CHECK-INST: udot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
-// CHECK-ENCODING: [0x18,0x00,0xd0,0xc1]
+sdot    za.s[w8, 0], {z0.b-z1.b}, z0.b[0]  // 11000001-01010000-00010000-00100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, z0.b[0]
+// CHECK-ENCODING: [0x20,0x10,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d00018 <unknown>
+// CHECK-UNKNOWN: c1501020 <unknown>
 
-udot    za.d[w10, 5, vgx2], {z10.h-z11.h}, z5.h[1]  // 11000001-11010101-01000101-01011101
-// CHECK-INST: udot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x5d,0x45,0xd5,0xc1]
+sdot    za.s[w10, 5, vgx2], {z10.b-z11.b}, z5.b[1]  // 11000001-01010101-01010101-01100101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b[1]
+// CHECK-ENCODING: [0x65,0x55,0x55,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d5455d <unknown>
+// CHECK-UNKNOWN: c1555565 <unknown>
 
-udot    za.d[w10, 5], {z10.h-z11.h}, z5.h[1]  // 11000001-11010101-01000101-01011101
-// CHECK-INST: udot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x5d,0x45,0xd5,0xc1]
+sdot    za.s[w10, 5], {z10.b-z11.b}, z5.b[1]  // 11000001-01010101-01010101-01100101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, z5.b[1]
+// CHECK-ENCODING: [0x65,0x55,0x55,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d5455d <unknown>
+// CHECK-UNKNOWN: c1555565 <unknown>
 
-udot    za.d[w11, 7, vgx2], {z12.h-z13.h}, z8.h[1]  // 11000001-11011000-01100101-10011111
-// CHECK-INST: udot    za.d[w11, 7, vgx2], { z12.h-z13.h }, z8.h[1]
-// CHECK-ENCODING: [0x9f,0x65,0xd8,0xc1]
+sdot    za.s[w11, 7, vgx2], {z12.b-z13.b}, z8.b[3]  // 11000001-01011000-01111101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.b-z13.b }, z8.b[3]
+// CHECK-ENCODING: [0xa7,0x7d,0x58,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d8659f <unknown>
+// CHECK-UNKNOWN: c1587da7 <unknown>
 
-udot    za.d[w11, 7], {z12.h-z13.h}, z8.h[1]  // 11000001-11011000-01100101-10011111
-// CHECK-INST: udot    za.d[w11, 7, vgx2], { z12.h-z13.h }, z8.h[1]
-// CHECK-ENCODING: [0x9f,0x65,0xd8,0xc1]
+sdot    za.s[w11, 7], {z12.b-z13.b}, z8.b[3]  // 11000001-01011000-01111101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.b-z13.b }, z8.b[3]
+// CHECK-ENCODING: [0xa7,0x7d,0x58,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d8659f <unknown>
+// CHECK-UNKNOWN: c1587da7 <unknown>
 
-udot    za.d[w11, 7, vgx2], {z30.h-z31.h}, z15.h[1]  // 11000001-11011111-01100111-11011111
-// CHECK-INST: udot    za.d[w11, 7, vgx2], { z30.h-z31.h }, z15.h[1]
-// CHECK-ENCODING: [0xdf,0x67,0xdf,0xc1]
+sdot    za.s[w11, 7, vgx2], {z30.b-z31.b}, z15.b[3]  // 11000001-01011111-01111111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.b-z31.b }, z15.b[3]
+// CHECK-ENCODING: [0xe7,0x7f,0x5f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1df67df <unknown>
+// CHECK-UNKNOWN: c15f7fe7 <unknown>
 
-udot    za.d[w11, 7], {z30.h-z31.h}, z15.h[1]  // 11000001-11011111-01100111-11011111
-// CHECK-INST: udot    za.d[w11, 7, vgx2], { z30.h-z31.h }, z15.h[1]
-// CHECK-ENCODING: [0xdf,0x67,0xdf,0xc1]
+sdot    za.s[w11, 7], {z30.b-z31.b}, z15.b[3]  // 11000001-01011111-01111111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.b-z31.b }, z15.b[3]
+// CHECK-ENCODING: [0xe7,0x7f,0x5f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1df67df <unknown>
+// CHECK-UNKNOWN: c15f7fe7 <unknown>
 
-udot    za.d[w8, 5, vgx2], {z16.h-z17.h}, z0.h[1]  // 11000001-11010000-00000110-00011101
-// CHECK-INST: udot    za.d[w8, 5, vgx2], { z16.h-z17.h }, z0.h[1]
-// CHECK-ENCODING: [0x1d,0x06,0xd0,0xc1]
+sdot    za.s[w8, 5, vgx2], {z16.b-z17.b}, z0.b[3]  // 11000001-01010000-00011110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.b-z17.b }, z0.b[3]
+// CHECK-ENCODING: [0x25,0x1e,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d0061d <unknown>
+// CHECK-UNKNOWN: c1501e25 <unknown>
 
-udot    za.d[w8, 5], {z16.h-z17.h}, z0.h[1]  // 11000001-11010000-00000110-00011101
-// CHECK-INST: udot    za.d[w8, 5, vgx2], { z16.h-z17.h }, z0.h[1]
-// CHECK-ENCODING: [0x1d,0x06,0xd0,0xc1]
+sdot    za.s[w8, 5], {z16.b-z17.b}, z0.b[3]  // 11000001-01010000-00011110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.b-z17.b }, z0.b[3]
+// CHECK-ENCODING: [0x25,0x1e,0x50,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d0061d <unknown>
+// CHECK-UNKNOWN: c1501e25 <unknown>
 
-udot    za.d[w8, 1, vgx2], {z0.h-z1.h}, z14.h[1]  // 11000001-11011110-00000100-00011001
-// CHECK-INST: udot    za.d[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
-// CHECK-ENCODING: [0x19,0x04,0xde,0xc1]
+sdot    za.s[w8, 1, vgx2], {z0.b-z1.b}, z14.b[1]  // 11000001-01011110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.b-z1.b }, z14.b[1]
+// CHECK-ENCODING: [0x21,0x14,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de0419 <unknown>
+// CHECK-UNKNOWN: c15e1421 <unknown>
 
-udot    za.d[w8, 1], {z0.h-z1.h}, z14.h[1]  // 11000001-11011110-00000100-00011001
-// CHECK-INST: udot    za.d[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
-// CHECK-ENCODING: [0x19,0x04,0xde,0xc1]
+sdot    za.s[w8, 1], {z0.b-z1.b}, z14.b[1]  // 11000001-01011110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.b-z1.b }, z14.b[1]
+// CHECK-ENCODING: [0x21,0x14,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de0419 <unknown>
+// CHECK-UNKNOWN: c15e1421 <unknown>
 
-udot    za.d[w10, 0, vgx2], {z18.h-z19.h}, z4.h[1]  // 11000001-11010100-01000110-01011000
-// CHECK-INST: udot    za.d[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x58,0x46,0xd4,0xc1]
+sdot    za.s[w10, 0, vgx2], {z18.b-z19.b}, z4.b[1]  // 11000001-01010100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.b-z19.b }, z4.b[1]
+// CHECK-ENCODING: [0x60,0x56,0x54,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d44658 <unknown>
+// CHECK-UNKNOWN: c1545660 <unknown>
 
-udot    za.d[w10, 0], {z18.h-z19.h}, z4.h[1]  // 11000001-11010100-01000110-01011000
-// CHECK-INST: udot    za.d[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x58,0x46,0xd4,0xc1]
+sdot    za.s[w10, 0], {z18.b-z19.b}, z4.b[1]  // 11000001-01010100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.b-z19.b }, z4.b[1]
+// CHECK-ENCODING: [0x60,0x56,0x54,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d44658 <unknown>
+// CHECK-UNKNOWN: c1545660 <unknown>
 
-udot    za.d[w8, 0, vgx2], {z12.h-z13.h}, z2.h[0]  // 11000001-11010010-00000001-10011000
-// CHECK-INST: udot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h[0]
-// CHECK-ENCODING: [0x98,0x01,0xd2,0xc1]
+sdot    za.s[w8, 0, vgx2], {z12.b-z13.b}, z2.b[2]  // 11000001-01010010-00011001-10100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b[2]
+// CHECK-ENCODING: [0xa0,0x19,0x52,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d20198 <unknown>
+// CHECK-UNKNOWN: c15219a0 <unknown>
 
-udot    za.d[w8, 0], {z12.h-z13.h}, z2.h[0]  // 11000001-11010010-00000001-10011000
-// CHECK-INST: udot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h[0]
-// CHECK-ENCODING: [0x98,0x01,0xd2,0xc1]
+sdot    za.s[w8, 0], {z12.b-z13.b}, z2.b[2]  // 11000001-01010010-00011001-10100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, z2.b[2]
+// CHECK-ENCODING: [0xa0,0x19,0x52,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d20198 <unknown>
+// CHECK-UNKNOWN: c15219a0 <unknown>
 
-udot    za.d[w10, 1, vgx2], {z0.h-z1.h}, z10.h[0]  // 11000001-11011010-01000000-00011001
-// CHECK-INST: udot    za.d[w10, 1, vgx2], { z0.h-z1.h }, z10.h[0]
-// CHECK-ENCODING: [0x19,0x40,0xda,0xc1]
+sdot    za.s[w10, 1, vgx2], {z0.b-z1.b}, z10.b[2]  // 11000001-01011010-01011000-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.b-z1.b }, z10.b[2]
+// CHECK-ENCODING: [0x21,0x58,0x5a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1da4019 <unknown>
+// CHECK-UNKNOWN: c15a5821 <unknown>
 
-udot    za.d[w10, 1], {z0.h-z1.h}, z10.h[0]  // 11000001-11011010-01000000-00011001
-// CHECK-INST: udot    za.d[w10, 1, vgx2], { z0.h-z1.h }, z10.h[0]
-// CHECK-ENCODING: [0x19,0x40,0xda,0xc1]
+sdot    za.s[w10, 1], {z0.b-z1.b}, z10.b[2]  // 11000001-01011010-01011000-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.b-z1.b }, z10.b[2]
+// CHECK-ENCODING: [0x21,0x58,0x5a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1da4019 <unknown>
+// CHECK-UNKNOWN: c15a5821 <unknown>
 
-udot    za.d[w8, 5, vgx2], {z22.h-z23.h}, z14.h[0]  // 11000001-11011110-00000010-11011101
-// CHECK-INST: udot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h[0]
-// CHECK-ENCODING: [0xdd,0x02,0xde,0xc1]
+sdot    za.s[w8, 5, vgx2], {z22.b-z23.b}, z14.b[2]  // 11000001-01011110-00011010-11100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b[2]
+// CHECK-ENCODING: [0xe5,0x1a,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de02dd <unknown>
+// CHECK-UNKNOWN: c15e1ae5 <unknown>
 
-udot    za.d[w8, 5], {z22.h-z23.h}, z14.h[0]  // 11000001-11011110-00000010-11011101
-// CHECK-INST: udot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h[0]
-// CHECK-ENCODING: [0xdd,0x02,0xde,0xc1]
+sdot    za.s[w8, 5], {z22.b-z23.b}, z14.b[2]  // 11000001-01011110-00011010-11100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, z14.b[2]
+// CHECK-ENCODING: [0xe5,0x1a,0x5e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de02dd <unknown>
+// CHECK-UNKNOWN: c15e1ae5 <unknown>
 
-udot    za.d[w11, 2, vgx2], {z8.h-z9.h}, z1.h[1]  // 11000001-11010001-01100101-00011010
-// CHECK-INST: udot    za.d[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
-// CHECK-ENCODING: [0x1a,0x65,0xd1,0xc1]
+sdot    za.s[w11, 2, vgx2], {z8.b-z9.b}, z1.b[1]  // 11000001-01010001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.b-z9.b }, z1.b[1]
+// CHECK-ENCODING: [0x22,0x75,0x51,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d1651a <unknown>
+// CHECK-UNKNOWN: c1517522 <unknown>
 
-udot    za.d[w11, 2], {z8.h-z9.h}, z1.h[1]  // 11000001-11010001-01100101-00011010
-// CHECK-INST: udot    za.d[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
-// CHECK-ENCODING: [0x1a,0x65,0xd1,0xc1]
+sdot    za.s[w11, 2], {z8.b-z9.b}, z1.b[1]  // 11000001-01010001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.b-z9.b }, z1.b[1]
+// CHECK-ENCODING: [0x22,0x75,0x51,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d1651a <unknown>
+// CHECK-UNKNOWN: c1517522 <unknown>
 
-udot    za.d[w9, 7, vgx2], {z12.h-z13.h}, z11.h[0]  // 11000001-11011011-00100001-10011111
-// CHECK-INST: udot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h[0]
-// CHECK-ENCODING: [0x9f,0x21,0xdb,0xc1]
+sdot    za.s[w9, 7, vgx2], {z12.b-z13.b}, z11.b[2]  // 11000001-01011011-00111001-10100111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b[2]
+// CHECK-ENCODING: [0xa7,0x39,0x5b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1db219f <unknown>
+// CHECK-UNKNOWN: c15b39a7 <unknown>
 
-udot    za.d[w9, 7], {z12.h-z13.h}, z11.h[0]  // 11000001-11011011-00100001-10011111
-// CHECK-INST: udot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h[0]
-// CHECK-ENCODING: [0x9f,0x21,0xdb,0xc1]
+sdot    za.s[w9, 7], {z12.b-z13.b}, z11.b[2]  // 11000001-01011011-00111001-10100111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, z11.b[2]
+// CHECK-ENCODING: [0xa7,0x39,0x5b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1db219f <unknown>
+// CHECK-UNKNOWN: c15b39a7 <unknown>
 
 
-udot    za.s[w8, 0, vgx4], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h
-// CHECK-ENCODING: [0x18,0x14,0x70,0xc1]
+sdot    za.s[w8, 0, vgx2], {z0.b-z1.b}, {z0.b-z1.b}  // 11000001-10100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x00,0x14,0xa0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1701418 <unknown>
+// CHECK-UNKNOWN: c1a01400 <unknown>
 
-udot    za.s[w8, 0], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h
-// CHECK-ENCODING: [0x18,0x14,0x70,0xc1]
+sdot    za.s[w8, 0], {z0.b-z1.b}, {z0.b-z1.b}  // 11000001-10100000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z0.b-z1.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x00,0x14,0xa0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1701418 <unknown>
+// CHECK-UNKNOWN: c1a01400 <unknown>
 
-udot    za.s[w10, 5, vgx4], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01011101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z10.h-z13.h }, z5.h
-// CHECK-ENCODING: [0x5d,0x55,0x75,0xc1]
+sdot    za.s[w10, 5, vgx2], {z10.b-z11.b}, {z20.b-z21.b}  // 11000001-10110100-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x45,0x55,0xb4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c175555d <unknown>
+// CHECK-UNKNOWN: c1b45545 <unknown>
 
-udot    za.s[w10, 5], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01011101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z10.h-z13.h }, z5.h
-// CHECK-ENCODING: [0x5d,0x55,0x75,0xc1]
+sdot    za.s[w10, 5], {z10.b-z11.b}, {z20.b-z21.b}  // 11000001-10110100-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx2], { z10.b-z11.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x45,0x55,0xb4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c175555d <unknown>
+// CHECK-UNKNOWN: c1b45545 <unknown>
 
-udot    za.s[w11, 7, vgx4], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10111111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z13.h-z16.h }, z8.h
-// CHECK-ENCODING: [0xbf,0x75,0x78,0xc1]
+sdot    za.s[w11, 7, vgx2], {z12.b-z13.b}, {z8.b-z9.b}  // 11000001-10101000-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.b-z13.b }, { z8.b-z9.b }
+// CHECK-ENCODING: [0x87,0x75,0xa8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17875bf <unknown>
+// CHECK-UNKNOWN: c1a87587 <unknown>
 
-udot    za.s[w11, 7], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10111111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z13.h-z16.h }, z8.h
-// CHECK-ENCODING: [0xbf,0x75,0x78,0xc1]
+sdot    za.s[w11, 7], {z12.b-z13.b}, {z8.b-z9.b}  // 11000001-10101000-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z12.b-z13.b }, { z8.b-z9.b }
+// CHECK-ENCODING: [0x87,0x75,0xa8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17875bf <unknown>
+// CHECK-UNKNOWN: c1a87587 <unknown>
 
-udot    za.s[w11, 7, vgx4], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11111111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z31.h-z2.h }, z15.h
-// CHECK-ENCODING: [0xff,0x77,0x7f,0xc1]
+sdot    za.s[w11, 7, vgx2], {z30.b-z31.b}, {z30.b-z31.b}  // 11000001-10111110-01110111-11000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.b-z31.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc7,0x77,0xbe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17f77ff <unknown>
+// CHECK-UNKNOWN: c1be77c7 <unknown>
 
-udot    za.s[w11, 7], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11111111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z31.h-z2.h }, z15.h
-// CHECK-ENCODING: [0xff,0x77,0x7f,0xc1]
+sdot    za.s[w11, 7], {z30.b-z31.b}, {z30.b-z31.b}  // 11000001-10111110-01110111-11000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx2], { z30.b-z31.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc7,0x77,0xbe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17f77ff <unknown>
+// CHECK-UNKNOWN: c1be77c7 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00111101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z17.h-z20.h }, z0.h
-// CHECK-ENCODING: [0x3d,0x16,0x70,0xc1]
+sdot    za.s[w8, 5, vgx2], {z16.b-z17.b}, {z16.b-z17.b}  // 11000001-10110000-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.b-z17.b }, { z16.b-z17.b }
+// CHECK-ENCODING: [0x05,0x16,0xb0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c170163d <unknown>
+// CHECK-UNKNOWN: c1b01605 <unknown>
 
-udot    za.s[w8, 5], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00111101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z17.h-z20.h }, z0.h
-// CHECK-ENCODING: [0x3d,0x16,0x70,0xc1]
+sdot    za.s[w8, 5], {z16.b-z17.b}, {z16.b-z17.b}  // 11000001-10110000-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z16.b-z17.b }, { z16.b-z17.b }
+// CHECK-ENCODING: [0x05,0x16,0xb0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c170163d <unknown>
+// CHECK-UNKNOWN: c1b01605 <unknown>
 
-udot    za.s[w8, 1, vgx4], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00111001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z1.h-z4.h }, z14.h
-// CHECK-ENCODING: [0x39,0x14,0x7e,0xc1]
+sdot    za.s[w8, 1, vgx2], {z0.b-z1.b}, {z30.b-z31.b}  // 11000001-10111110-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.b-z1.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17e1439 <unknown>
+// CHECK-UNKNOWN: c1be1401 <unknown>
 
-udot    za.s[w8, 1], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00111001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z1.h-z4.h }, z14.h
-// CHECK-ENCODING: [0x39,0x14,0x7e,0xc1]
+sdot    za.s[w8, 1], {z0.b-z1.b}, {z30.b-z31.b}  // 11000001-10111110-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx2], { z0.b-z1.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17e1439 <unknown>
+// CHECK-UNKNOWN: c1be1401 <unknown>
 
-udot    za.s[w10, 0, vgx4], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01111000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z19.h-z22.h }, z4.h
-// CHECK-ENCODING: [0x78,0x56,0x74,0xc1]
+sdot    za.s[w10, 0, vgx2], {z18.b-z19.b}, {z20.b-z21.b}  // 11000001-10110100-01010110-01000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.b-z19.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x40,0x56,0xb4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1745678 <unknown>
+// CHECK-UNKNOWN: c1b45640 <unknown>
 
-udot    za.s[w10, 0], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01111000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z19.h-z22.h }, z4.h
-// CHECK-ENCODING: [0x78,0x56,0x74,0xc1]
+sdot    za.s[w10, 0], {z18.b-z19.b}, {z20.b-z21.b}  // 11000001-10110100-01010110-01000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx2], { z18.b-z19.b }, { z20.b-z21.b }
+// CHECK-ENCODING: [0x40,0x56,0xb4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1745678 <unknown>
+// CHECK-UNKNOWN: c1b45640 <unknown>
 
-udot    za.s[w8, 0, vgx4], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h
-// CHECK-ENCODING: [0x98,0x15,0x72,0xc1]
+sdot    za.s[w8, 0, vgx2], {z12.b-z13.b}, {z2.b-z3.b}  // 11000001-10100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, { z2.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1721598 <unknown>
+// CHECK-UNKNOWN: c1a21580 <unknown>
 
-udot    za.s[w8, 0], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h
-// CHECK-ENCODING: [0x98,0x15,0x72,0xc1]
+sdot    za.s[w8, 0], {z12.b-z13.b}, {z2.b-z3.b}  // 11000001-10100010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx2], { z12.b-z13.b }, { z2.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1721598 <unknown>
+// CHECK-UNKNOWN: c1a21580 <unknown>
 
-udot    za.s[w10, 1, vgx4], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00111001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z1.h-z4.h }, z10.h
-// CHECK-ENCODING: [0x39,0x54,0x7a,0xc1]
+sdot    za.s[w10, 1, vgx2], {z0.b-z1.b}, {z26.b-z27.b}  // 11000001-10111010-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.b-z1.b }, { z26.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xba,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17a5439 <unknown>
+// CHECK-UNKNOWN: c1ba5401 <unknown>
 
-udot    za.s[w10, 1], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00111001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z1.h-z4.h }, z10.h
-// CHECK-ENCODING: [0x39,0x54,0x7a,0xc1]
+sdot    za.s[w10, 1], {z0.b-z1.b}, {z26.b-z27.b}  // 11000001-10111010-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx2], { z0.b-z1.b }, { z26.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xba,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17a5439 <unknown>
+// CHECK-UNKNOWN: c1ba5401 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11011101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z22.h-z25.h }, z14.h
-// CHECK-ENCODING: [0xdd,0x16,0x7e,0xc1]
+sdot    za.s[w8, 5, vgx2], {z22.b-z23.b}, {z30.b-z31.b}  // 11000001-10111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc5,0x16,0xbe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17e16dd <unknown>
+// CHECK-UNKNOWN: c1be16c5 <unknown>
 
-udot    za.s[w8, 5], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11011101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z22.h-z25.h }, z14.h
-// CHECK-ENCODING: [0xdd,0x16,0x7e,0xc1]
+sdot    za.s[w8, 5], {z22.b-z23.b}, {z30.b-z31.b}  // 11000001-10111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx2], { z22.b-z23.b }, { z30.b-z31.b }
+// CHECK-ENCODING: [0xc5,0x16,0xbe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17e16dd <unknown>
+// CHECK-UNKNOWN: c1be16c5 <unknown>
 
-udot    za.s[w11, 2, vgx4], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00111010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z9.h-z12.h }, z1.h
-// CHECK-ENCODING: [0x3a,0x75,0x71,0xc1]
+sdot    za.s[w11, 2, vgx2], {z8.b-z9.b}, {z0.b-z1.b}  // 11000001-10100000-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.b-z9.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x02,0x75,0xa0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c171753a <unknown>
+// CHECK-UNKNOWN: c1a07502 <unknown>
 
-udot    za.s[w11, 2], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00111010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z9.h-z12.h }, z1.h
-// CHECK-ENCODING: [0x3a,0x75,0x71,0xc1]
+sdot    za.s[w11, 2], {z8.b-z9.b}, {z0.b-z1.b}  // 11000001-10100000-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx2], { z8.b-z9.b }, { z0.b-z1.b }
+// CHECK-ENCODING: [0x02,0x75,0xa0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c171753a <unknown>
+// CHECK-UNKNOWN: c1a07502 <unknown>
 
-udot    za.s[w9, 7, vgx4], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h
-// CHECK-ENCODING: [0x9f,0x35,0x7b,0xc1]
+sdot    za.s[w9, 7, vgx2], {z12.b-z13.b}, {z10.b-z11.b}  // 11000001-10101010-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, { z10.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xaa,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17b359f <unknown>
+// CHECK-UNKNOWN: c1aa3587 <unknown>
 
-udot    za.s[w9, 7], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h
-// CHECK-ENCODING: [0x9f,0x35,0x7b,0xc1]
+sdot    za.s[w9, 7], {z12.b-z13.b}, {z10.b-z11.b}  // 11000001-10101010-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx2], { z12.b-z13.b }, { z10.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xaa,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c17b359f <unknown>
+// CHECK-UNKNOWN: c1aa3587 <unknown>
 
 
-udot    za.s[w8, 0, vgx4], {z0.h-z3.h}, z0.h[0]  // 11000001-01010000-10010000-00010000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
-// CHECK-ENCODING: [0x10,0x90,0x50,0xc1]
+sdot    za.d[w8, 0, vgx2], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509010 <unknown>
+// CHECK-UNKNOWN: c1601400 <unknown>
 
-udot    za.s[w8, 0], {z0.h-z3.h}, z0.h[0]  // 11000001-01010000-10010000-00010000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
-// CHECK-ENCODING: [0x10,0x90,0x50,0xc1]
+sdot    za.d[w8, 0], {z0.h-z1.h}, z0.h  // 11000001-01100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509010 <unknown>
+// CHECK-UNKNOWN: c1601400 <unknown>
 
-udot    za.s[w10, 5, vgx4], {z8.h-z11.h}, z5.h[1]  // 11000001-01010101-11010101-00010101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x15,0xd5,0x55,0xc1]
+sdot    za.d[w10, 5, vgx2], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x65,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c155d515 <unknown>
+// CHECK-UNKNOWN: c1655545 <unknown>
 
-udot    za.s[w10, 5], {z8.h-z11.h}, z5.h[1]  // 11000001-01010101-11010101-00010101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x15,0xd5,0x55,0xc1]
+sdot    za.d[w10, 5], {z10.h-z11.h}, z5.h  // 11000001-01100101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x65,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c155d515 <unknown>
+// CHECK-UNKNOWN: c1655545 <unknown>
 
-udot    za.s[w11, 7, vgx4], {z12.h-z15.h}, z8.h[3]  // 11000001-01011000-11111101-10010111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z12.h-z15.h }, z8.h[3]
-// CHECK-ENCODING: [0x97,0xfd,0x58,0xc1]
+sdot    za.d[w11, 7, vgx2], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z13.h-z14.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x68,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c158fd97 <unknown>
+// CHECK-UNKNOWN: c16875a7 <unknown>
 
-udot    za.s[w11, 7], {z12.h-z15.h}, z8.h[3]  // 11000001-01011000-11111101-10010111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z12.h-z15.h }, z8.h[3]
-// CHECK-ENCODING: [0x97,0xfd,0x58,0xc1]
+sdot    za.d[w11, 7], {z13.h-z14.h}, z8.h  // 11000001-01101000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z13.h-z14.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x68,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c158fd97 <unknown>
+// CHECK-UNKNOWN: c16875a7 <unknown>
 
-udot    za.s[w11, 7, vgx4], {z28.h-z31.h}, z15.h[3]  // 11000001-01011111-11111111-10010111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z28.h-z31.h }, z15.h[3]
-// CHECK-ENCODING: [0x97,0xff,0x5f,0xc1]
+sdot    za.d[w11, 7, vgx2], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z31.h-z0.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x6f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15fff97 <unknown>
+// CHECK-UNKNOWN: c16f77e7 <unknown>
 
-udot    za.s[w11, 7], {z28.h-z31.h}, z15.h[3]  // 11000001-01011111-11111111-10010111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z28.h-z31.h }, z15.h[3]
-// CHECK-ENCODING: [0x97,0xff,0x5f,0xc1]
+sdot    za.d[w11, 7], {z31.h-z0.h}, z15.h  // 11000001-01101111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z31.h-z0.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x6f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15fff97 <unknown>
+// CHECK-UNKNOWN: c16f77e7 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z16.h-z19.h}, z0.h[3]  // 11000001-01010000-10011110-00010101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z16.h-z19.h }, z0.h[3]
-// CHECK-ENCODING: [0x15,0x9e,0x50,0xc1]
+sdot    za.d[w8, 5, vgx2], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z17.h-z18.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509e15 <unknown>
+// CHECK-UNKNOWN: c1601625 <unknown>
 
-udot    za.s[w8, 5], {z16.h-z19.h}, z0.h[3]  // 11000001-01010000-10011110-00010101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z16.h-z19.h }, z0.h[3]
-// CHECK-ENCODING: [0x15,0x9e,0x50,0xc1]
+sdot    za.d[w8, 5], {z17.h-z18.h}, z0.h  // 11000001-01100000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z17.h-z18.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x60,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509e15 <unknown>
+// CHECK-UNKNOWN: c1601625 <unknown>
 
-udot    za.s[w8, 1, vgx4], {z0.h-z3.h}, z14.h[1]  // 11000001-01011110-10010100-00010001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
-// CHECK-ENCODING: [0x11,0x94,0x5e,0xc1]
+sdot    za.d[w8, 1, vgx2], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z1.h-z2.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9411 <unknown>
+// CHECK-UNKNOWN: c16e1421 <unknown>
 
-udot    za.s[w8, 1], {z0.h-z3.h}, z14.h[1]  // 11000001-01011110-10010100-00010001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
-// CHECK-ENCODING: [0x11,0x94,0x5e,0xc1]
+sdot    za.d[w8, 1], {z1.h-z2.h}, z14.h  // 11000001-01101110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z1.h-z2.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9411 <unknown>
+// CHECK-UNKNOWN: c16e1421 <unknown>
 
-udot    za.s[w10, 0, vgx4], {z16.h-z19.h}, z4.h[1]  // 11000001-01010100-11010110-00010000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x10,0xd6,0x54,0xc1]
+sdot    za.d[w10, 0, vgx2], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z19.h-z20.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x64,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c154d610 <unknown>
+// CHECK-UNKNOWN: c1645660 <unknown>
 
-udot    za.s[w10, 0], {z16.h-z19.h}, z4.h[1]  // 11000001-01010100-11010110-00010000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x10,0xd6,0x54,0xc1]
+sdot    za.d[w10, 0], {z19.h-z20.h}, z4.h  // 11000001-01100100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z19.h-z20.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x64,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c154d610 <unknown>
+// CHECK-UNKNOWN: c1645660 <unknown>
 
-udot    za.s[w8, 0, vgx4], {z12.h-z15.h}, z2.h[2]  // 11000001-01010010-10011001-10010000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h[2]
-// CHECK-ENCODING: [0x90,0x99,0x52,0xc1]
+sdot    za.d[w8, 0, vgx2], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x62,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1529990 <unknown>
+// CHECK-UNKNOWN: c1621580 <unknown>
 
-udot    za.s[w8, 0], {z12.h-z15.h}, z2.h[2]  // 11000001-01010010-10011001-10010000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h[2]
-// CHECK-ENCODING: [0x90,0x99,0x52,0xc1]
+sdot    za.d[w8, 0], {z12.h-z13.h}, z2.h  // 11000001-01100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x62,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1529990 <unknown>
+// CHECK-UNKNOWN: c1621580 <unknown>
 
-udot    za.s[w10, 1, vgx4], {z0.h-z3.h}, z10.h[2]  // 11000001-01011010-11011000-00010001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z0.h-z3.h }, z10.h[2]
-// CHECK-ENCODING: [0x11,0xd8,0x5a,0xc1]
+sdot    za.d[w10, 1, vgx2], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z1.h-z2.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x6a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15ad811 <unknown>
+// CHECK-UNKNOWN: c16a5421 <unknown>
 
-udot    za.s[w10, 1], {z0.h-z3.h}, z10.h[2]  // 11000001-01011010-11011000-00010001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z0.h-z3.h }, z10.h[2]
-// CHECK-ENCODING: [0x11,0xd8,0x5a,0xc1]
+sdot    za.d[w10, 1], {z1.h-z2.h}, z10.h  // 11000001-01101010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z1.h-z2.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x6a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15ad811 <unknown>
+// CHECK-UNKNOWN: c16a5421 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z20.h-z23.h}, z14.h[2]  // 11000001-01011110-10011010-10010101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z20.h-z23.h }, z14.h[2]
-// CHECK-ENCODING: [0x95,0x9a,0x5e,0xc1]
+sdot    za.d[w8, 5, vgx2], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9a95 <unknown>
+// CHECK-UNKNOWN: c16e16c5 <unknown>
 
-udot    za.s[w8, 5], {z20.h-z23.h}, z14.h[2]  // 11000001-01011110-10011010-10010101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z20.h-z23.h }, z14.h[2]
-// CHECK-ENCODING: [0x95,0x9a,0x5e,0xc1]
+sdot    za.d[w8, 5], {z22.h-z23.h}, z14.h  // 11000001-01101110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x6e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9a95 <unknown>
+// CHECK-UNKNOWN: c16e16c5 <unknown>
 
-udot    za.s[w11, 2, vgx4], {z8.h-z11.h}, z1.h[1]  // 11000001-01010001-11110101-00010010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
-// CHECK-ENCODING: [0x12,0xf5,0x51,0xc1]
+sdot    za.d[w11, 2, vgx2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z9.h-z10.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x61,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c151f512 <unknown>
+// CHECK-UNKNOWN: c1617522 <unknown>
 
-udot    za.s[w11, 2], {z8.h-z11.h}, z1.h[1]  // 11000001-01010001-11110101-00010010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
-// CHECK-ENCODING: [0x12,0xf5,0x51,0xc1]
+sdot    za.d[w11, 2], {z9.h-z10.h}, z1.h  // 11000001-01100001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z9.h-z10.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x61,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c151f512 <unknown>
+// CHECK-UNKNOWN: c1617522 <unknown>
 
-udot    za.s[w9, 7, vgx4], {z12.h-z15.h}, z11.h[2]  // 11000001-01011011-10111001-10010111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h[2]
-// CHECK-ENCODING: [0x97,0xb9,0x5b,0xc1]
+sdot    za.d[w9, 7, vgx2], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x6b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15bb997 <unknown>
+// CHECK-UNKNOWN: c16b3587 <unknown>
 
-udot    za.s[w9, 7], {z12.h-z15.h}, z11.h[2]  // 11000001-01011011-10111001-10010111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h[2]
-// CHECK-ENCODING: [0x97,0xb9,0x5b,0xc1]
+sdot    za.d[w9, 7], {z12.h-z13.h}, z11.h  // 11000001-01101011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x6b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15bb997 <unknown>
+// CHECK-UNKNOWN: c16b3587 <unknown>
 
 
-udot    za.s[w8, 0, vgx4], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
-// CHECK-ENCODING: [0x18,0x14,0xe1,0xc1]
+sdot    za.d[w8, 0, vgx2], {z0.h-z1.h}, z0.h[0]  // 11000001-11010000-00000000-00001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
+// CHECK-ENCODING: [0x08,0x00,0xd0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e11418 <unknown>
+// CHECK-UNKNOWN: c1d00008 <unknown>
 
-udot    za.s[w8, 0], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
-// CHECK-ENCODING: [0x18,0x14,0xe1,0xc1]
+sdot    za.d[w8, 0], {z0.h-z1.h}, z0.h[0]  // 11000001-11010000-00000000-00001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, z0.h[0]
+// CHECK-ENCODING: [0x08,0x00,0xd0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e11418 <unknown>
+// CHECK-UNKNOWN: c1d00008 <unknown>
 
-udot    za.s[w10, 5, vgx4], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00011101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
-// CHECK-ENCODING: [0x1d,0x55,0xf5,0xc1]
+sdot    za.d[w10, 5, vgx2], {z10.h-z11.h}, z5.h[1]  // 11000001-11010101-01000101-01001101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x4d,0x45,0xd5,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f5551d <unknown>
+// CHECK-UNKNOWN: c1d5454d <unknown>
 
-udot    za.s[w10, 5], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00011101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
-// CHECK-ENCODING: [0x1d,0x55,0xf5,0xc1]
+sdot    za.d[w10, 5], {z10.h-z11.h}, z5.h[1]  // 11000001-11010101-01000101-01001101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x4d,0x45,0xd5,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f5551d <unknown>
+// CHECK-UNKNOWN: c1d5454d <unknown>
 
-udot    za.s[w11, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10011111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
-// CHECK-ENCODING: [0x9f,0x75,0xe9,0xc1]
+sdot    za.d[w11, 7, vgx2], {z12.h-z13.h}, z8.h[1]  // 11000001-11011000-01100101-10001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z12.h-z13.h }, z8.h[1]
+// CHECK-ENCODING: [0x8f,0x65,0xd8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e9759f <unknown>
+// CHECK-UNKNOWN: c1d8658f <unknown>
 
-udot    za.s[w11, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10011111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
-// CHECK-ENCODING: [0x9f,0x75,0xe9,0xc1]
+sdot    za.d[w11, 7], {z12.h-z13.h}, z8.h[1]  // 11000001-11011000-01100101-10001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z12.h-z13.h }, z8.h[1]
+// CHECK-ENCODING: [0x8f,0x65,0xd8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e9759f <unknown>
+// CHECK-UNKNOWN: c1d8658f <unknown>
 
-udot    za.s[w11, 7, vgx4], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10011111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
-// CHECK-ENCODING: [0x9f,0x77,0xfd,0xc1]
+sdot    za.d[w11, 7, vgx2], {z30.h-z31.h}, z15.h[1]  // 11000001-11011111-01100111-11001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z30.h-z31.h }, z15.h[1]
+// CHECK-ENCODING: [0xcf,0x67,0xdf,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fd779f <unknown>
+// CHECK-UNKNOWN: c1df67cf <unknown>
 
-udot    za.s[w11, 7], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10011111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
-// CHECK-ENCODING: [0x9f,0x77,0xfd,0xc1]
+sdot    za.d[w11, 7], {z30.h-z31.h}, z15.h[1]  // 11000001-11011111-01100111-11001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z30.h-z31.h }, z15.h[1]
+// CHECK-ENCODING: [0xcf,0x67,0xdf,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fd779f <unknown>
+// CHECK-UNKNOWN: c1df67cf <unknown>
 
-udot    za.s[w8, 5, vgx4], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00011101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
-// CHECK-ENCODING: [0x1d,0x16,0xf1,0xc1]
+sdot    za.d[w8, 5, vgx2], {z16.h-z17.h}, z0.h[1]  // 11000001-11010000-00000110-00001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z16.h-z17.h }, z0.h[1]
+// CHECK-ENCODING: [0x0d,0x06,0xd0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f1161d <unknown>
+// CHECK-UNKNOWN: c1d0060d <unknown>
 
-udot    za.s[w8, 5], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00011101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
-// CHECK-ENCODING: [0x1d,0x16,0xf1,0xc1]
+sdot    za.d[w8, 5], {z16.h-z17.h}, z0.h[1]  // 11000001-11010000-00000110-00001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z16.h-z17.h }, z0.h[1]
+// CHECK-ENCODING: [0x0d,0x06,0xd0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f1161d <unknown>
+// CHECK-UNKNOWN: c1d0060d <unknown>
 
-udot    za.s[w8, 1, vgx4], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00011001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
-// CHECK-ENCODING: [0x19,0x14,0xfd,0xc1]
+sdot    za.d[w8, 1, vgx2], {z0.h-z1.h}, z14.h[1]  // 11000001-11011110-00000100-00001001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
+// CHECK-ENCODING: [0x09,0x04,0xde,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fd1419 <unknown>
+// CHECK-UNKNOWN: c1de0409 <unknown>
 
-udot    za.s[w8, 1], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00011001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
-// CHECK-ENCODING: [0x19,0x14,0xfd,0xc1]
+sdot    za.d[w8, 1], {z0.h-z1.h}, z14.h[1]  // 11000001-11011110-00000100-00001001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z0.h-z1.h }, z14.h[1]
+// CHECK-ENCODING: [0x09,0x04,0xde,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fd1419 <unknown>
+// CHECK-UNKNOWN: c1de0409 <unknown>
 
-udot    za.s[w10, 0, vgx4], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00011000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
-// CHECK-ENCODING: [0x18,0x56,0xf5,0xc1]
+sdot    za.d[w10, 0, vgx2], {z18.h-z19.h}, z4.h[1]  // 11000001-11010100-01000110-01001000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x48,0x46,0xd4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f55618 <unknown>
+// CHECK-UNKNOWN: c1d44648 <unknown>
 
-udot    za.s[w10, 0], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00011000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
-// CHECK-ENCODING: [0x18,0x56,0xf5,0xc1]
+sdot    za.d[w10, 0], {z18.h-z19.h}, z4.h[1]  // 11000001-11010100-01000110-01001000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z18.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x48,0x46,0xd4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f55618 <unknown>
+// CHECK-UNKNOWN: c1d44648 <unknown>
 
-udot    za.s[w8, 0, vgx4], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
-// CHECK-ENCODING: [0x98,0x15,0xe1,0xc1]
+sdot    za.d[w8, 0, vgx2], {z12.h-z13.h}, z2.h[0]  // 11000001-11010010-00000001-10001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h[0]
+// CHECK-ENCODING: [0x88,0x01,0xd2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e11598 <unknown>
+// CHECK-UNKNOWN: c1d20188 <unknown>
 
-udot    za.s[w8, 0], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10011000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
-// CHECK-ENCODING: [0x98,0x15,0xe1,0xc1]
+sdot    za.d[w8, 0], {z12.h-z13.h}, z2.h[0]  // 11000001-11010010-00000001-10001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, z2.h[0]
+// CHECK-ENCODING: [0x88,0x01,0xd2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e11598 <unknown>
+// CHECK-UNKNOWN: c1d20188 <unknown>
 
-udot    za.s[w10, 1, vgx4], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00011001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
-// CHECK-ENCODING: [0x19,0x54,0xf9,0xc1]
+sdot    za.d[w10, 1, vgx2], {z0.h-z1.h}, z10.h[0]  // 11000001-11011010-01000000-00001001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z0.h-z1.h }, z10.h[0]
+// CHECK-ENCODING: [0x09,0x40,0xda,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f95419 <unknown>
+// CHECK-UNKNOWN: c1da4009 <unknown>
 
-udot    za.s[w10, 1], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00011001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
-// CHECK-ENCODING: [0x19,0x54,0xf9,0xc1]
+sdot    za.d[w10, 1], {z0.h-z1.h}, z10.h[0]  // 11000001-11011010-01000000-00001001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z0.h-z1.h }, z10.h[0]
+// CHECK-ENCODING: [0x09,0x40,0xda,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1f95419 <unknown>
+// CHECK-UNKNOWN: c1da4009 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10011101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
-// CHECK-ENCODING: [0x9d,0x16,0xfd,0xc1]
+sdot    za.d[w8, 5, vgx2], {z22.h-z23.h}, z14.h[0]  // 11000001-11011110-00000010-11001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h[0]
+// CHECK-ENCODING: [0xcd,0x02,0xde,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fd169d <unknown>
+// CHECK-UNKNOWN: c1de02cd <unknown>
 
-udot    za.s[w8, 5], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10011101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
-// CHECK-ENCODING: [0x9d,0x16,0xfd,0xc1]
+sdot    za.d[w8, 5], {z22.h-z23.h}, z14.h[0]  // 11000001-11011110-00000010-11001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, z14.h[0]
+// CHECK-ENCODING: [0xcd,0x02,0xde,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1fd169d <unknown>
+// CHECK-UNKNOWN: c1de02cd <unknown>
 
-udot    za.s[w11, 2, vgx4], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00011010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
-// CHECK-ENCODING: [0x1a,0x75,0xe1,0xc1]
+sdot    za.d[w11, 2, vgx2], {z8.h-z9.h}, z1.h[1]  // 11000001-11010001-01100101-00001010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
+// CHECK-ENCODING: [0x0a,0x65,0xd1,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e1751a <unknown>
+// CHECK-UNKNOWN: c1d1650a <unknown>
 
-udot    za.s[w11, 2], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00011010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
-// CHECK-ENCODING: [0x1a,0x75,0xe1,0xc1]
+sdot    za.d[w11, 2], {z8.h-z9.h}, z1.h[1]  // 11000001-11010001-01100101-00001010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z8.h-z9.h }, z1.h[1]
+// CHECK-ENCODING: [0x0a,0x65,0xd1,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e1751a <unknown>
+// CHECK-UNKNOWN: c1d1650a <unknown>
 
-udot    za.s[w9, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
-// CHECK-ENCODING: [0x9f,0x35,0xe9,0xc1]
+sdot    za.d[w9, 7, vgx2], {z12.h-z13.h}, z11.h[0]  // 11000001-11011011-00100001-10001111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h[0]
+// CHECK-ENCODING: [0x8f,0x21,0xdb,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e9359f <unknown>
+// CHECK-UNKNOWN: c1db218f <unknown>
 
-udot    za.s[w9, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10011111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
-// CHECK-ENCODING: [0x9f,0x35,0xe9,0xc1]
+sdot    za.d[w9, 7], {z12.h-z13.h}, z11.h[0]  // 11000001-11011011-00100001-10001111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, z11.h[0]
+// CHECK-ENCODING: [0x8f,0x21,0xdb,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1e9359f <unknown>
+// CHECK-UNKNOWN: c1db218f <unknown>
 
 
-udot    za.s[w8, 0, vgx4], {z0.b-z3.b}, z0.b[0]  // 11000001-01010000-10010000-00110000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b[0]
-// CHECK-ENCODING: [0x30,0x90,0x50,0xc1]
+sdot    za.d[w8, 0, vgx2], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x00,0x14,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509030 <unknown>
+// CHECK-UNKNOWN: c1e01400 <unknown>
 
-udot    za.s[w8, 0], {z0.b-z3.b}, z0.b[0]  // 11000001-01010000-10010000-00110000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b[0]
-// CHECK-ENCODING: [0x30,0x90,0x50,0xc1]
+sdot    za.d[w8, 0], {z0.h-z1.h}, {z0.h-z1.h}  // 11000001-11100000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z0.h-z1.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x00,0x14,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509030 <unknown>
+// CHECK-UNKNOWN: c1e01400 <unknown>
 
-udot    za.s[w10, 5, vgx4], {z8.b-z11.b}, z5.b[1]  // 11000001-01010101-11010101-00110101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z8.b-z11.b }, z5.b[1]
-// CHECK-ENCODING: [0x35,0xd5,0x55,0xc1]
+sdot    za.d[w10, 5, vgx2], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x45,0x55,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c155d535 <unknown>
+// CHECK-UNKNOWN: c1f45545 <unknown>
 
-udot    za.s[w10, 5], {z8.b-z11.b}, z5.b[1]  // 11000001-01010101-11010101-00110101
-// CHECK-INST: udot    za.s[w10, 5, vgx4], { z8.b-z11.b }, z5.b[1]
-// CHECK-ENCODING: [0x35,0xd5,0x55,0xc1]
+sdot    za.d[w10, 5], {z10.h-z11.h}, {z20.h-z21.h}  // 11000001-11110100-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx2], { z10.h-z11.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x45,0x55,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c155d535 <unknown>
+// CHECK-UNKNOWN: c1f45545 <unknown>
 
-udot    za.s[w11, 7, vgx4], {z12.b-z15.b}, z8.b[3]  // 11000001-01011000-11111101-10110111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z12.b-z15.b }, z8.b[3]
-// CHECK-ENCODING: [0xb7,0xfd,0x58,0xc1]
+sdot    za.d[w11, 7, vgx2], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
+// CHECK-ENCODING: [0x87,0x75,0xe8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c158fdb7 <unknown>
+// CHECK-UNKNOWN: c1e87587 <unknown>
 
-udot    za.s[w11, 7], {z12.b-z15.b}, z8.b[3]  // 11000001-01011000-11111101-10110111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z12.b-z15.b }, z8.b[3]
-// CHECK-ENCODING: [0xb7,0xfd,0x58,0xc1]
+sdot    za.d[w11, 7], {z12.h-z13.h}, {z8.h-z9.h}  // 11000001-11101000-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z12.h-z13.h }, { z8.h-z9.h }
+// CHECK-ENCODING: [0x87,0x75,0xe8,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c158fdb7 <unknown>
+// CHECK-UNKNOWN: c1e87587 <unknown>
 
-udot    za.s[w11, 7, vgx4], {z28.b-z31.b}, z15.b[3]  // 11000001-01011111-11111111-10110111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z28.b-z31.b }, z15.b[3]
-// CHECK-ENCODING: [0xb7,0xff,0x5f,0xc1]
+sdot    za.d[w11, 7, vgx2], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc7,0x77,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15fffb7 <unknown>
+// CHECK-UNKNOWN: c1fe77c7 <unknown>
 
-udot    za.s[w11, 7], {z28.b-z31.b}, z15.b[3]  // 11000001-01011111-11111111-10110111
-// CHECK-INST: udot    za.s[w11, 7, vgx4], { z28.b-z31.b }, z15.b[3]
-// CHECK-ENCODING: [0xb7,0xff,0x5f,0xc1]
+sdot    za.d[w11, 7], {z30.h-z31.h}, {z30.h-z31.h}  // 11000001-11111110-01110111-11000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx2], { z30.h-z31.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc7,0x77,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15fffb7 <unknown>
+// CHECK-UNKNOWN: c1fe77c7 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z16.b-z19.b}, z0.b[3]  // 11000001-01010000-10011110-00110101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z16.b-z19.b }, z0.b[3]
-// CHECK-ENCODING: [0x35,0x9e,0x50,0xc1]
+sdot    za.d[w8, 5, vgx2], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
+// CHECK-ENCODING: [0x05,0x16,0xf0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509e35 <unknown>
+// CHECK-UNKNOWN: c1f01605 <unknown>
 
-udot    za.s[w8, 5], {z16.b-z19.b}, z0.b[3]  // 11000001-01010000-10011110-00110101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z16.b-z19.b }, z0.b[3]
-// CHECK-ENCODING: [0x35,0x9e,0x50,0xc1]
+sdot    za.d[w8, 5], {z16.h-z17.h}, {z16.h-z17.h}  // 11000001-11110000-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z16.h-z17.h }, { z16.h-z17.h }
+// CHECK-ENCODING: [0x05,0x16,0xf0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1509e35 <unknown>
+// CHECK-UNKNOWN: c1f01605 <unknown>
 
-udot    za.s[w8, 1, vgx4], {z0.b-z3.b}, z14.b[1]  // 11000001-01011110-10010100-00110001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z0.b-z3.b }, z14.b[1]
-// CHECK-ENCODING: [0x31,0x94,0x5e,0xc1]
+sdot    za.d[w8, 1, vgx2], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9431 <unknown>
+// CHECK-UNKNOWN: c1fe1401 <unknown>
 
-udot    za.s[w8, 1], {z0.b-z3.b}, z14.b[1]  // 11000001-01011110-10010100-00110001
-// CHECK-INST: udot    za.s[w8, 1, vgx4], { z0.b-z3.b }, z14.b[1]
-// CHECK-ENCODING: [0x31,0x94,0x5e,0xc1]
+sdot    za.d[w8, 1], {z0.h-z1.h}, {z30.h-z31.h}  // 11000001-11111110-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx2], { z0.h-z1.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9431 <unknown>
+// CHECK-UNKNOWN: c1fe1401 <unknown>
 
-udot    za.s[w10, 0, vgx4], {z16.b-z19.b}, z4.b[1]  // 11000001-01010100-11010110-00110000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z16.b-z19.b }, z4.b[1]
-// CHECK-ENCODING: [0x30,0xd6,0x54,0xc1]
+sdot    za.d[w10, 0, vgx2], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x40,0x56,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c154d630 <unknown>
+// CHECK-UNKNOWN: c1f45640 <unknown>
 
-udot    za.s[w10, 0], {z16.b-z19.b}, z4.b[1]  // 11000001-01010100-11010110-00110000
-// CHECK-INST: udot    za.s[w10, 0, vgx4], { z16.b-z19.b }, z4.b[1]
-// CHECK-ENCODING: [0x30,0xd6,0x54,0xc1]
+sdot    za.d[w10, 0], {z18.h-z19.h}, {z20.h-z21.h}  // 11000001-11110100-01010110-01000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx2], { z18.h-z19.h }, { z20.h-z21.h }
+// CHECK-ENCODING: [0x40,0x56,0xf4,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c154d630 <unknown>
+// CHECK-UNKNOWN: c1f45640 <unknown>
 
-udot    za.s[w8, 0, vgx4], {z12.b-z15.b}, z2.b[2]  // 11000001-01010010-10011001-10110000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b[2]
-// CHECK-ENCODING: [0xb0,0x99,0x52,0xc1]
+sdot    za.d[w8, 0, vgx2], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15299b0 <unknown>
+// CHECK-UNKNOWN: c1e21580 <unknown>
 
-udot    za.s[w8, 0], {z12.b-z15.b}, z2.b[2]  // 11000001-01010010-10011001-10110000
-// CHECK-INST: udot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b[2]
-// CHECK-ENCODING: [0xb0,0x99,0x52,0xc1]
+sdot    za.d[w8, 0], {z12.h-z13.h}, {z2.h-z3.h}  // 11000001-11100010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx2], { z12.h-z13.h }, { z2.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe2,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15299b0 <unknown>
+// CHECK-UNKNOWN: c1e21580 <unknown>
 
-udot    za.s[w10, 1, vgx4], {z0.b-z3.b}, z10.b[2]  // 11000001-01011010-11011000-00110001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z0.b-z3.b }, z10.b[2]
-// CHECK-ENCODING: [0x31,0xd8,0x5a,0xc1]
+sdot    za.d[w10, 1, vgx2], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xfa,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15ad831 <unknown>
+// CHECK-UNKNOWN: c1fa5401 <unknown>
 
-udot    za.s[w10, 1], {z0.b-z3.b}, z10.b[2]  // 11000001-01011010-11011000-00110001
-// CHECK-INST: udot    za.s[w10, 1, vgx4], { z0.b-z3.b }, z10.b[2]
-// CHECK-ENCODING: [0x31,0xd8,0x5a,0xc1]
+sdot    za.d[w10, 1], {z0.h-z1.h}, {z26.h-z27.h}  // 11000001-11111010-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx2], { z0.h-z1.h }, { z26.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xfa,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15ad831 <unknown>
+// CHECK-UNKNOWN: c1fa5401 <unknown>
 
-udot    za.s[w8, 5, vgx4], {z20.b-z23.b}, z14.b[2]  // 11000001-01011110-10011010-10110101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z20.b-z23.b }, z14.b[2]
-// CHECK-ENCODING: [0xb5,0x9a,0x5e,0xc1]
+sdot    za.d[w8, 5, vgx2], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc5,0x16,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9ab5 <unknown>
+// CHECK-UNKNOWN: c1fe16c5 <unknown>
 
-udot    za.s[w8, 5], {z20.b-z23.b}, z14.b[2]  // 11000001-01011110-10011010-10110101
-// CHECK-INST: udot    za.s[w8, 5, vgx4], { z20.b-z23.b }, z14.b[2]
-// CHECK-ENCODING: [0xb5,0x9a,0x5e,0xc1]
+sdot    za.d[w8, 5], {z22.h-z23.h}, {z30.h-z31.h}  // 11000001-11111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx2], { z22.h-z23.h }, { z30.h-z31.h }
+// CHECK-ENCODING: [0xc5,0x16,0xfe,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15e9ab5 <unknown>
+// CHECK-UNKNOWN: c1fe16c5 <unknown>
 
-udot    za.s[w11, 2, vgx4], {z8.b-z11.b}, z1.b[1]  // 11000001-01010001-11110101-00110010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z8.b-z11.b }, z1.b[1]
-// CHECK-ENCODING: [0x32,0xf5,0x51,0xc1]
+sdot    za.d[w11, 2, vgx2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x02,0x75,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c151f532 <unknown>
+// CHECK-UNKNOWN: c1e07502 <unknown>
 
-udot    za.s[w11, 2], {z8.b-z11.b}, z1.b[1]  // 11000001-01010001-11110101-00110010
-// CHECK-INST: udot    za.s[w11, 2, vgx4], { z8.b-z11.b }, z1.b[1]
-// CHECK-ENCODING: [0x32,0xf5,0x51,0xc1]
+sdot    za.d[w11, 2], {z8.h-z9.h}, {z0.h-z1.h}  // 11000001-11100000-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx2], { z8.h-z9.h }, { z0.h-z1.h }
+// CHECK-ENCODING: [0x02,0x75,0xe0,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c151f532 <unknown>
+// CHECK-UNKNOWN: c1e07502 <unknown>
 
-udot    za.s[w9, 7, vgx4], {z12.b-z15.b}, z11.b[2]  // 11000001-01011011-10111001-10110111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b[2]
-// CHECK-ENCODING: [0xb7,0xb9,0x5b,0xc1]
+sdot    za.d[w9, 7, vgx2], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xea,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15bb9b7 <unknown>
+// CHECK-UNKNOWN: c1ea3587 <unknown>
 
-udot    za.s[w9, 7], {z12.b-z15.b}, z11.b[2]  // 11000001-01011011-10111001-10110111
-// CHECK-INST: udot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b[2]
-// CHECK-ENCODING: [0xb7,0xb9,0x5b,0xc1]
+sdot    za.d[w9, 7], {z12.h-z13.h}, {z10.h-z11.h}  // 11000001-11101010-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx2], { z12.h-z13.h }, { z10.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xea,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c15bb9b7 <unknown>
+// CHECK-UNKNOWN: c1ea3587 <unknown>
 
 
-udot    za.d[w8, 0, vgx4], {z0.h-z3.h}, z0.h[0]  // 11000001-11010000-10000000-00011000
-// CHECK-INST: udot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
-// CHECK-ENCODING: [0x18,0x80,0xd0,0xc1]
+sdot    za.s[w8, 0, vgx4], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h
+// CHECK-ENCODING: [0x08,0x14,0x70,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d08018 <unknown>
+// CHECK-UNKNOWN: c1701408 <unknown>
 
-udot    za.d[w8, 0], {z0.h-z3.h}, z0.h[0]  // 11000001-11010000-10000000-00011000
-// CHECK-INST: udot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
-// CHECK-ENCODING: [0x18,0x80,0xd0,0xc1]
+sdot    za.s[w8, 0], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h
+// CHECK-ENCODING: [0x08,0x14,0x70,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d08018 <unknown>
+// CHECK-UNKNOWN: c1701408 <unknown>
 
-udot    za.d[w10, 5, vgx4], {z8.h-z11.h}, z5.h[1]  // 11000001-11010101-11000101-00011101
-// CHECK-INST: udot    za.d[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x1d,0xc5,0xd5,0xc1]
+sdot    za.s[w10, 5, vgx4], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z10.h-z13.h }, z5.h
+// CHECK-ENCODING: [0x4d,0x55,0x75,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d5c51d <unknown>
+// CHECK-UNKNOWN: c175554d <unknown>
 
-udot    za.d[w10, 5], {z8.h-z11.h}, z5.h[1]  // 11000001-11010101-11000101-00011101
-// CHECK-INST: udot    za.d[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
-// CHECK-ENCODING: [0x1d,0xc5,0xd5,0xc1]
+sdot    za.s[w10, 5], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z10.h-z13.h }, z5.h
+// CHECK-ENCODING: [0x4d,0x55,0x75,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d5c51d <unknown>
+// CHECK-UNKNOWN: c175554d <unknown>
 
-udot    za.d[w11, 7, vgx4], {z12.h-z15.h}, z8.h[1]  // 11000001-11011000-11100101-10011111
-// CHECK-INST: udot    za.d[w11, 7, vgx4], { z12.h-z15.h }, z8.h[1]
-// CHECK-ENCODING: [0x9f,0xe5,0xd8,0xc1]
+sdot    za.s[w11, 7, vgx4], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z13.h-z16.h }, z8.h
+// CHECK-ENCODING: [0xaf,0x75,0x78,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d8e59f <unknown>
+// CHECK-UNKNOWN: c17875af <unknown>
 
-udot    za.d[w11, 7], {z12.h-z15.h}, z8.h[1]  // 11000001-11011000-11100101-10011111
-// CHECK-INST: udot    za.d[w11, 7, vgx4], { z12.h-z15.h }, z8.h[1]
-// CHECK-ENCODING: [0x9f,0xe5,0xd8,0xc1]
+sdot    za.s[w11, 7], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z13.h-z16.h }, z8.h
+// CHECK-ENCODING: [0xaf,0x75,0x78,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d8e59f <unknown>
+// CHECK-UNKNOWN: c17875af <unknown>
 
-udot    za.d[w11, 7, vgx4], {z28.h-z31.h}, z15.h[1]  // 11000001-11011111-11100111-10011111
-// CHECK-INST: udot    za.d[w11, 7, vgx4], { z28.h-z31.h }, z15.h[1]
-// CHECK-ENCODING: [0x9f,0xe7,0xdf,0xc1]
+sdot    za.s[w11, 7, vgx4], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z31.h-z2.h }, z15.h
+// CHECK-ENCODING: [0xef,0x77,0x7f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1dfe79f <unknown>
+// CHECK-UNKNOWN: c17f77ef <unknown>
 
-udot    za.d[w11, 7], {z28.h-z31.h}, z15.h[1]  // 11000001-11011111-11100111-10011111
-// CHECK-INST: udot    za.d[w11, 7, vgx4], { z28.h-z31.h }, z15.h[1]
-// CHECK-ENCODING: [0x9f,0xe7,0xdf,0xc1]
+sdot    za.s[w11, 7], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11101111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z31.h-z2.h }, z15.h
+// CHECK-ENCODING: [0xef,0x77,0x7f,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1dfe79f <unknown>
+// CHECK-UNKNOWN: c17f77ef <unknown>
 
-udot    za.d[w8, 5, vgx4], {z16.h-z19.h}, z0.h[1]  // 11000001-11010000-10000110-00011101
-// CHECK-INST: udot    za.d[w8, 5, vgx4], { z16.h-z19.h }, z0.h[1]
-// CHECK-ENCODING: [0x1d,0x86,0xd0,0xc1]
+sdot    za.s[w8, 5, vgx4], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00101101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z17.h-z20.h }, z0.h
+// CHECK-ENCODING: [0x2d,0x16,0x70,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d0861d <unknown>
+// CHECK-UNKNOWN: c170162d <unknown>
 
-udot    za.d[w8, 5], {z16.h-z19.h}, z0.h[1]  // 11000001-11010000-10000110-00011101
-// CHECK-INST: udot    za.d[w8, 5, vgx4], { z16.h-z19.h }, z0.h[1]
-// CHECK-ENCODING: [0x1d,0x86,0xd0,0xc1]
+sdot    za.s[w8, 5], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00101101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z17.h-z20.h }, z0.h
+// CHECK-ENCODING: [0x2d,0x16,0x70,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d0861d <unknown>
+// CHECK-UNKNOWN: c170162d <unknown>
 
-udot    za.d[w8, 1, vgx4], {z0.h-z3.h}, z14.h[1]  // 11000001-11011110-10000100-00011001
-// CHECK-INST: udot    za.d[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
-// CHECK-ENCODING: [0x19,0x84,0xde,0xc1]
+sdot    za.s[w8, 1, vgx4], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00101001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z1.h-z4.h }, z14.h
+// CHECK-ENCODING: [0x29,0x14,0x7e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de8419 <unknown>
+// CHECK-UNKNOWN: c17e1429 <unknown>
 
-udot    za.d[w8, 1], {z0.h-z3.h}, z14.h[1]  // 11000001-11011110-10000100-00011001
-// CHECK-INST: udot    za.d[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
-// CHECK-ENCODING: [0x19,0x84,0xde,0xc1]
+sdot    za.s[w8, 1], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00101001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z1.h-z4.h }, z14.h
+// CHECK-ENCODING: [0x29,0x14,0x7e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de8419 <unknown>
+// CHECK-UNKNOWN: c17e1429 <unknown>
 
-udot    za.d[w10, 0, vgx4], {z16.h-z19.h}, z4.h[1]  // 11000001-11010100-11000110-00011000
-// CHECK-INST: udot    za.d[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x18,0xc6,0xd4,0xc1]
+sdot    za.s[w10, 0, vgx4], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01101000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z19.h-z22.h }, z4.h
+// CHECK-ENCODING: [0x68,0x56,0x74,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d4c618 <unknown>
+// CHECK-UNKNOWN: c1745668 <unknown>
 
-udot    za.d[w10, 0], {z16.h-z19.h}, z4.h[1]  // 11000001-11010100-11000110-00011000
-// CHECK-INST: udot    za.d[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
-// CHECK-ENCODING: [0x18,0xc6,0xd4,0xc1]
+sdot    za.s[w10, 0], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01101000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z19.h-z22.h }, z4.h
+// CHECK-ENCODING: [0x68,0x56,0x74,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d4c618 <unknown>
+// CHECK-UNKNOWN: c1745668 <unknown>
 
-udot    za.d[w8, 0, vgx4], {z12.h-z15.h}, z2.h[0]  // 11000001-11010010-10000001-10011000
-// CHECK-INST: udot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h[0]
-// CHECK-ENCODING: [0x98,0x81,0xd2,0xc1]
+sdot    za.s[w8, 0, vgx4], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h
+// CHECK-ENCODING: [0x88,0x15,0x72,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d28198 <unknown>
+// CHECK-UNKNOWN: c1721588 <unknown>
 
-udot    za.d[w8, 0], {z12.h-z15.h}, z2.h[0]  // 11000001-11010010-10000001-10011000
-// CHECK-INST: udot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h[0]
-// CHECK-ENCODING: [0x98,0x81,0xd2,0xc1]
+sdot    za.s[w8, 0], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h
+// CHECK-ENCODING: [0x88,0x15,0x72,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d28198 <unknown>
+// CHECK-UNKNOWN: c1721588 <unknown>
 
-udot    za.d[w10, 1, vgx4], {z0.h-z3.h}, z10.h[0]  // 11000001-11011010-11000000-00011001
-// CHECK-INST: udot    za.d[w10, 1, vgx4], { z0.h-z3.h }, z10.h[0]
-// CHECK-ENCODING: [0x19,0xc0,0xda,0xc1]
+sdot    za.s[w10, 1, vgx4], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00101001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z1.h-z4.h }, z10.h
+// CHECK-ENCODING: [0x29,0x54,0x7a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1dac019 <unknown>
+// CHECK-UNKNOWN: c17a5429 <unknown>
 
-udot    za.d[w10, 1], {z0.h-z3.h}, z10.h[0]  // 11000001-11011010-11000000-00011001
-// CHECK-INST: udot    za.d[w10, 1, vgx4], { z0.h-z3.h }, z10.h[0]
-// CHECK-ENCODING: [0x19,0xc0,0xda,0xc1]
+sdot    za.s[w10, 1], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00101001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z1.h-z4.h }, z10.h
+// CHECK-ENCODING: [0x29,0x54,0x7a,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1dac019 <unknown>
+// CHECK-UNKNOWN: c17a5429 <unknown>
 
-udot    za.d[w8, 5, vgx4], {z20.h-z23.h}, z14.h[0]  // 11000001-11011110-10000010-10011101
-// CHECK-INST: udot    za.d[w8, 5, vgx4], { z20.h-z23.h }, z14.h[0]
-// CHECK-ENCODING: [0x9d,0x82,0xde,0xc1]
+sdot    za.s[w8, 5, vgx4], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z22.h-z25.h }, z14.h
+// CHECK-ENCODING: [0xcd,0x16,0x7e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de829d <unknown>
+// CHECK-UNKNOWN: c17e16cd <unknown>
 
-udot    za.d[w8, 5], {z20.h-z23.h}, z14.h[0]  // 11000001-11011110-10000010-10011101
-// CHECK-INST: udot    za.d[w8, 5, vgx4], { z20.h-z23.h }, z14.h[0]
-// CHECK-ENCODING: [0x9d,0x82,0xde,0xc1]
+sdot    za.s[w8, 5], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z22.h-z25.h }, z14.h
+// CHECK-ENCODING: [0xcd,0x16,0x7e,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1de829d <unknown>
+// CHECK-UNKNOWN: c17e16cd <unknown>
 
-udot    za.d[w11, 2, vgx4], {z8.h-z11.h}, z1.h[1]  // 11000001-11010001-11100101-00011010
-// CHECK-INST: udot    za.d[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
-// CHECK-ENCODING: [0x1a,0xe5,0xd1,0xc1]
+sdot    za.s[w11, 2, vgx4], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00101010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z9.h-z12.h }, z1.h
+// CHECK-ENCODING: [0x2a,0x75,0x71,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d1e51a <unknown>
+// CHECK-UNKNOWN: c171752a <unknown>
 
-udot    za.d[w11, 2], {z8.h-z11.h}, z1.h[1]  // 11000001-11010001-11100101-00011010
-// CHECK-INST: udot    za.d[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
-// CHECK-ENCODING: [0x1a,0xe5,0xd1,0xc1]
+sdot    za.s[w11, 2], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00101010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z9.h-z12.h }, z1.h
+// CHECK-ENCODING: [0x2a,0x75,0x71,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1d1e51a <unknown>
+// CHECK-UNKNOWN: c171752a <unknown>
 
-udot    za.d[w9, 7, vgx4], {z12.h-z15.h}, z11.h[0]  // 11000001-11011011-10100001-10011111
-// CHECK-INST: udot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h[0]
-// CHECK-ENCODING: [0x9f,0xa1,0xdb,0xc1]
+sdot    za.s[w9, 7, vgx4], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h
+// CHECK-ENCODING: [0x8f,0x35,0x7b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1dba19f <unknown>
+// CHECK-UNKNOWN: c17b358f <unknown>
 
-udot    za.d[w9, 7], {z12.h-z15.h}, z11.h[0]  // 11000001-11011011-10100001-10011111
-// CHECK-INST: udot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h[0]
-// CHECK-ENCODING: [0x9f,0xa1,0xdb,0xc1]
+sdot    za.s[w9, 7], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h
+// CHECK-ENCODING: [0x8f,0x35,0x7b,0xc1]
 // CHECK-ERROR: instruction requires: sme2
-// CHECK-UNKNOWN: c1dba19f <unknown>
+// CHECK-UNKNOWN: c17b358f <unknown>
+
+
+sdot    za.s[w8, 0, vgx4], {z0.h-z3.h}, z0.h[0]  // 11000001-01010000-10010000-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
+// CHECK-ENCODING: [0x00,0x90,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509000 <unknown>
+
+sdot    za.s[w8, 0], {z0.h-z3.h}, z0.h[0]  // 11000001-01010000-10010000-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
+// CHECK-ENCODING: [0x00,0x90,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509000 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z8.h-z11.h}, z5.h[1]  // 11000001-01010101-11010101-00000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x05,0xd5,0x55,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c155d505 <unknown>
+
+sdot    za.s[w10, 5], {z8.h-z11.h}, z5.h[1]  // 11000001-01010101-11010101-00000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x05,0xd5,0x55,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c155d505 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z12.h-z15.h}, z8.h[3]  // 11000001-01011000-11111101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.h-z15.h }, z8.h[3]
+// CHECK-ENCODING: [0x87,0xfd,0x58,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c158fd87 <unknown>
+
+sdot    za.s[w11, 7], {z12.h-z15.h}, z8.h[3]  // 11000001-01011000-11111101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.h-z15.h }, z8.h[3]
+// CHECK-ENCODING: [0x87,0xfd,0x58,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c158fd87 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z28.h-z31.h}, z15.h[3]  // 11000001-01011111-11111111-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.h-z31.h }, z15.h[3]
+// CHECK-ENCODING: [0x87,0xff,0x5f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15fff87 <unknown>
+
+sdot    za.s[w11, 7], {z28.h-z31.h}, z15.h[3]  // 11000001-01011111-11111111-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.h-z31.h }, z15.h[3]
+// CHECK-ENCODING: [0x87,0xff,0x5f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15fff87 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z16.h-z19.h}, z0.h[3]  // 11000001-01010000-10011110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.h-z19.h }, z0.h[3]
+// CHECK-ENCODING: [0x05,0x9e,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509e05 <unknown>
+
+sdot    za.s[w8, 5], {z16.h-z19.h}, z0.h[3]  // 11000001-01010000-10011110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.h-z19.h }, z0.h[3]
+// CHECK-ENCODING: [0x05,0x9e,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509e05 <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z0.h-z3.h}, z14.h[1]  // 11000001-01011110-10010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
+// CHECK-ENCODING: [0x01,0x94,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9401 <unknown>
+
+sdot    za.s[w8, 1], {z0.h-z3.h}, z14.h[1]  // 11000001-01011110-10010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
+// CHECK-ENCODING: [0x01,0x94,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9401 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z16.h-z19.h}, z4.h[1]  // 11000001-01010100-11010110-00000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x00,0xd6,0x54,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c154d600 <unknown>
+
+sdot    za.s[w10, 0], {z16.h-z19.h}, z4.h[1]  // 11000001-01010100-11010110-00000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x00,0xd6,0x54,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c154d600 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.h-z15.h}, z2.h[2]  // 11000001-01010010-10011001-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h[2]
+// CHECK-ENCODING: [0x80,0x99,0x52,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1529980 <unknown>
+
+sdot    za.s[w8, 0], {z12.h-z15.h}, z2.h[2]  // 11000001-01010010-10011001-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.h-z15.h }, z2.h[2]
+// CHECK-ENCODING: [0x80,0x99,0x52,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1529980 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z0.h-z3.h}, z10.h[2]  // 11000001-01011010-11011000-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.h-z3.h }, z10.h[2]
+// CHECK-ENCODING: [0x01,0xd8,0x5a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15ad801 <unknown>
+
+sdot    za.s[w10, 1], {z0.h-z3.h}, z10.h[2]  // 11000001-01011010-11011000-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.h-z3.h }, z10.h[2]
+// CHECK-ENCODING: [0x01,0xd8,0x5a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15ad801 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z20.h-z23.h}, z14.h[2]  // 11000001-01011110-10011010-10000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.h-z23.h }, z14.h[2]
+// CHECK-ENCODING: [0x85,0x9a,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9a85 <unknown>
+
+sdot    za.s[w8, 5], {z20.h-z23.h}, z14.h[2]  // 11000001-01011110-10011010-10000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.h-z23.h }, z14.h[2]
+// CHECK-ENCODING: [0x85,0x9a,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9a85 <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z8.h-z11.h}, z1.h[1]  // 11000001-01010001-11110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
+// CHECK-ENCODING: [0x02,0xf5,0x51,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c151f502 <unknown>
+
+sdot    za.s[w11, 2], {z8.h-z11.h}, z1.h[1]  // 11000001-01010001-11110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
+// CHECK-ENCODING: [0x02,0xf5,0x51,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c151f502 <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.h-z15.h}, z11.h[2]  // 11000001-01011011-10111001-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h[2]
+// CHECK-ENCODING: [0x87,0xb9,0x5b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15bb987 <unknown>
+
+sdot    za.s[w9, 7], {z12.h-z15.h}, z11.h[2]  // 11000001-01011011-10111001-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, z11.h[2]
+// CHECK-ENCODING: [0x87,0xb9,0x5b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15bb987 <unknown>
+
+
+sdot    za.s[w8, 0, vgx4], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x08,0x14,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11408 <unknown>
+
+sdot    za.s[w8, 0], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x08,0x14,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11408 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x0d,0x55,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f5550d <unknown>
+
+sdot    za.s[w10, 5], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00001101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x0d,0x55,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f5550d <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x8f,0x75,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e9758f <unknown>
+
+sdot    za.s[w11, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x8f,0x75,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e9758f <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x8f,0x77,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd778f <unknown>
+
+sdot    za.s[w11, 7], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10001111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x8f,0x77,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd778f <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
+// CHECK-ENCODING: [0x0d,0x16,0xf1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f1160d <unknown>
+
+sdot    za.s[w8, 5], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
+// CHECK-ENCODING: [0x0d,0x16,0xf1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f1160d <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00001001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x09,0x14,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1409 <unknown>
+
+sdot    za.s[w8, 1], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00001001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x09,0x14,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1409 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00001000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x08,0x56,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55608 <unknown>
+
+sdot    za.s[w10, 0], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00001000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x08,0x56,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55608 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x88,0x15,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11588 <unknown>
+
+sdot    za.s[w8, 0], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10001000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x88,0x15,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11588 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00001001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
+// CHECK-ENCODING: [0x09,0x54,0xf9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f95409 <unknown>
+
+sdot    za.s[w10, 1], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00001001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
+// CHECK-ENCODING: [0x09,0x54,0xf9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f95409 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x8d,0x16,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd168d <unknown>
+
+sdot    za.s[w8, 5], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10001101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x8d,0x16,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd168d <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00001010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x0a,0x75,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e1750a <unknown>
+
+sdot    za.s[w11, 2], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00001010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x0a,0x75,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e1750a <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x8f,0x35,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e9358f <unknown>
+
+sdot    za.s[w9, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10001111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x8f,0x35,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e9358f <unknown>
+
+
+sdot    za.s[w8, 0, vgx4], {z0.b-z3.b}, z0.b  // 11000001-00110000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301400 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z3.b}, z0.b  // 11000001-00110000-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b
+// CHECK-ENCODING: [0x00,0x14,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301400 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z10.b-z13.b}, z5.b  // 11000001-00110101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z10.b-z13.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x35,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1355545 <unknown>
+
+sdot    za.s[w10, 5], {z10.b-z13.b}, z5.b  // 11000001-00110101-01010101-01000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z10.b-z13.b }, z5.b
+// CHECK-ENCODING: [0x45,0x55,0x35,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1355545 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z13.b-z16.b}, z8.b  // 11000001-00111000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z13.b-z16.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x38,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13875a7 <unknown>
+
+sdot    za.s[w11, 7], {z13.b-z16.b}, z8.b  // 11000001-00111000-01110101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z13.b-z16.b }, z8.b
+// CHECK-ENCODING: [0xa7,0x75,0x38,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13875a7 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z31.b-z2.b}, z15.b  // 11000001-00111111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z31.b-z2.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x3f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13f77e7 <unknown>
+
+sdot    za.s[w11, 7], {z31.b-z2.b}, z15.b  // 11000001-00111111-01110111-11100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z31.b-z2.b }, z15.b
+// CHECK-ENCODING: [0xe7,0x77,0x3f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13f77e7 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z17.b-z20.b}, z0.b  // 11000001-00110000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z17.b-z20.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301625 <unknown>
+
+sdot    za.s[w8, 5], {z17.b-z20.b}, z0.b  // 11000001-00110000-00010110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z17.b-z20.b }, z0.b
+// CHECK-ENCODING: [0x25,0x16,0x30,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1301625 <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z1.b-z4.b}, z14.b  // 11000001-00111110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z1.b-z4.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e1421 <unknown>
+
+sdot    za.s[w8, 1], {z1.b-z4.b}, z14.b  // 11000001-00111110-00010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z1.b-z4.b }, z14.b
+// CHECK-ENCODING: [0x21,0x14,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e1421 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z19.b-z22.b}, z4.b  // 11000001-00110100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z19.b-z22.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x34,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1345660 <unknown>
+
+sdot    za.s[w10, 0], {z19.b-z22.b}, z4.b  // 11000001-00110100-01010110-01100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z19.b-z22.b }, z4.b
+// CHECK-ENCODING: [0x60,0x56,0x34,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1345660 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.b-z15.b}, z2.b  // 11000001-00110010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x32,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1321580 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z15.b}, z2.b  // 11000001-00110010-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b
+// CHECK-ENCODING: [0x80,0x15,0x32,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1321580 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z1.b-z4.b}, z10.b  // 11000001-00111010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z1.b-z4.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x3a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13a5421 <unknown>
+
+sdot    za.s[w10, 1], {z1.b-z4.b}, z10.b  // 11000001-00111010-01010100-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z1.b-z4.b }, z10.b
+// CHECK-ENCODING: [0x21,0x54,0x3a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13a5421 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z22.b-z25.b}, z14.b  // 11000001-00111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z22.b-z25.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e16c5 <unknown>
+
+sdot    za.s[w8, 5], {z22.b-z25.b}, z14.b  // 11000001-00111110-00010110-11000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z22.b-z25.b }, z14.b
+// CHECK-ENCODING: [0xc5,0x16,0x3e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13e16c5 <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z9.b-z12.b}, z1.b  // 11000001-00110001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z9.b-z12.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x31,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1317522 <unknown>
+
+sdot    za.s[w11, 2], {z9.b-z12.b}, z1.b  // 11000001-00110001-01110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z9.b-z12.b }, z1.b
+// CHECK-ENCODING: [0x22,0x75,0x31,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1317522 <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.b-z15.b}, z11.b  // 11000001-00111011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x3b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13b3587 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z15.b}, z11.b  // 11000001-00111011-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b
+// CHECK-ENCODING: [0x87,0x35,0x3b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c13b3587 <unknown>
+
+
+sdot    za.s[w8, 0, vgx4], {z0.b-z3.b}, z0.b[0]  // 11000001-01010000-10010000-00100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b[0]
+// CHECK-ENCODING: [0x20,0x90,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509020 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z3.b}, z0.b[0]  // 11000001-01010000-10010000-00100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, z0.b[0]
+// CHECK-ENCODING: [0x20,0x90,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509020 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z8.b-z11.b}, z5.b[1]  // 11000001-01010101-11010101-00100101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.b-z11.b }, z5.b[1]
+// CHECK-ENCODING: [0x25,0xd5,0x55,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c155d525 <unknown>
+
+sdot    za.s[w10, 5], {z8.b-z11.b}, z5.b[1]  // 11000001-01010101-11010101-00100101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.b-z11.b }, z5.b[1]
+// CHECK-ENCODING: [0x25,0xd5,0x55,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c155d525 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z12.b-z15.b}, z8.b[3]  // 11000001-01011000-11111101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.b-z15.b }, z8.b[3]
+// CHECK-ENCODING: [0xa7,0xfd,0x58,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c158fda7 <unknown>
+
+sdot    za.s[w11, 7], {z12.b-z15.b}, z8.b[3]  // 11000001-01011000-11111101-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.b-z15.b }, z8.b[3]
+// CHECK-ENCODING: [0xa7,0xfd,0x58,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c158fda7 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z28.b-z31.b}, z15.b[3]  // 11000001-01011111-11111111-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.b-z31.b }, z15.b[3]
+// CHECK-ENCODING: [0xa7,0xff,0x5f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15fffa7 <unknown>
+
+sdot    za.s[w11, 7], {z28.b-z31.b}, z15.b[3]  // 11000001-01011111-11111111-10100111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.b-z31.b }, z15.b[3]
+// CHECK-ENCODING: [0xa7,0xff,0x5f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15fffa7 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z16.b-z19.b}, z0.b[3]  // 11000001-01010000-10011110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.b-z19.b }, z0.b[3]
+// CHECK-ENCODING: [0x25,0x9e,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509e25 <unknown>
+
+sdot    za.s[w8, 5], {z16.b-z19.b}, z0.b[3]  // 11000001-01010000-10011110-00100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.b-z19.b }, z0.b[3]
+// CHECK-ENCODING: [0x25,0x9e,0x50,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1509e25 <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z0.b-z3.b}, z14.b[1]  // 11000001-01011110-10010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.b-z3.b }, z14.b[1]
+// CHECK-ENCODING: [0x21,0x94,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9421 <unknown>
+
+sdot    za.s[w8, 1], {z0.b-z3.b}, z14.b[1]  // 11000001-01011110-10010100-00100001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.b-z3.b }, z14.b[1]
+// CHECK-ENCODING: [0x21,0x94,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9421 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z16.b-z19.b}, z4.b[1]  // 11000001-01010100-11010110-00100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.b-z19.b }, z4.b[1]
+// CHECK-ENCODING: [0x20,0xd6,0x54,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c154d620 <unknown>
+
+sdot    za.s[w10, 0], {z16.b-z19.b}, z4.b[1]  // 11000001-01010100-11010110-00100000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.b-z19.b }, z4.b[1]
+// CHECK-ENCODING: [0x20,0xd6,0x54,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c154d620 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.b-z15.b}, z2.b[2]  // 11000001-01010010-10011001-10100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b[2]
+// CHECK-ENCODING: [0xa0,0x99,0x52,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15299a0 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z15.b}, z2.b[2]  // 11000001-01010010-10011001-10100000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, z2.b[2]
+// CHECK-ENCODING: [0xa0,0x99,0x52,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15299a0 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z0.b-z3.b}, z10.b[2]  // 11000001-01011010-11011000-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.b-z3.b }, z10.b[2]
+// CHECK-ENCODING: [0x21,0xd8,0x5a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15ad821 <unknown>
+
+sdot    za.s[w10, 1], {z0.b-z3.b}, z10.b[2]  // 11000001-01011010-11011000-00100001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.b-z3.b }, z10.b[2]
+// CHECK-ENCODING: [0x21,0xd8,0x5a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15ad821 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z20.b-z23.b}, z14.b[2]  // 11000001-01011110-10011010-10100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.b-z23.b }, z14.b[2]
+// CHECK-ENCODING: [0xa5,0x9a,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9aa5 <unknown>
+
+sdot    za.s[w8, 5], {z20.b-z23.b}, z14.b[2]  // 11000001-01011110-10011010-10100101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.b-z23.b }, z14.b[2]
+// CHECK-ENCODING: [0xa5,0x9a,0x5e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15e9aa5 <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z8.b-z11.b}, z1.b[1]  // 11000001-01010001-11110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.b-z11.b }, z1.b[1]
+// CHECK-ENCODING: [0x22,0xf5,0x51,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c151f522 <unknown>
+
+sdot    za.s[w11, 2], {z8.b-z11.b}, z1.b[1]  // 11000001-01010001-11110101-00100010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.b-z11.b }, z1.b[1]
+// CHECK-ENCODING: [0x22,0xf5,0x51,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c151f522 <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.b-z15.b}, z11.b[2]  // 11000001-01011011-10111001-10100111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b[2]
+// CHECK-ENCODING: [0xa7,0xb9,0x5b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15bb9a7 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z15.b}, z11.b[2]  // 11000001-01011011-10111001-10100111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, z11.b[2]
+// CHECK-ENCODING: [0xa7,0xb9,0x5b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c15bb9a7 <unknown>
+
+
+sdot    za.s[w8, 0, vgx4], {z0.b-z3.b}, {z0.b-z3.b}  // 11000001-10100001-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x00,0x14,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11400 <unknown>
+
+sdot    za.s[w8, 0], {z0.b-z3.b}, {z0.b-z3.b}  // 11000001-10100001-00010100-00000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z0.b-z3.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x00,0x14,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11400 <unknown>
+
+sdot    za.s[w10, 5, vgx4], {z8.b-z11.b}, {z20.b-z23.b}  // 11000001-10110101-01010101-00000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.b-z11.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x05,0x55,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55505 <unknown>
+
+sdot    za.s[w10, 5], {z8.b-z11.b}, {z20.b-z23.b}  // 11000001-10110101-01010101-00000101
+// CHECK-INST: sdot    za.s[w10, 5, vgx4], { z8.b-z11.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x05,0x55,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55505 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x75,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a97587 <unknown>
+
+sdot    za.s[w11, 7], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-01110101-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x75,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a97587 <unknown>
+
+sdot    za.s[w11, 7, vgx4], {z28.b-z31.b}, {z28.b-z31.b}  // 11000001-10111101-01110111-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.b-z31.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x87,0x77,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd7787 <unknown>
+
+sdot    za.s[w11, 7], {z28.b-z31.b}, {z28.b-z31.b}  // 11000001-10111101-01110111-10000111
+// CHECK-INST: sdot    za.s[w11, 7, vgx4], { z28.b-z31.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x87,0x77,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd7787 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z16.b-z19.b}, {z16.b-z19.b}  // 11000001-10110001-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.b-z19.b }, { z16.b-z19.b }
+// CHECK-ENCODING: [0x05,0x16,0xb1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b11605 <unknown>
+
+sdot    za.s[w8, 5], {z16.b-z19.b}, {z16.b-z19.b}  // 11000001-10110001-00010110-00000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z16.b-z19.b }, { z16.b-z19.b }
+// CHECK-ENCODING: [0x05,0x16,0xb1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b11605 <unknown>
+
+sdot    za.s[w8, 1, vgx4], {z0.b-z3.b}, {z28.b-z31.b}  // 11000001-10111101-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.b-z3.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1401 <unknown>
+
+sdot    za.s[w8, 1], {z0.b-z3.b}, {z28.b-z31.b}  // 11000001-10111101-00010100-00000001
+// CHECK-INST: sdot    za.s[w8, 1, vgx4], { z0.b-z3.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x01,0x14,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1401 <unknown>
+
+sdot    za.s[w10, 0, vgx4], {z16.b-z19.b}, {z20.b-z23.b}  // 11000001-10110101-01010110-00000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.b-z19.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x00,0x56,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55600 <unknown>
+
+sdot    za.s[w10, 0], {z16.b-z19.b}, {z20.b-z23.b}  // 11000001-10110101-01010110-00000000
+// CHECK-INST: sdot    za.s[w10, 0, vgx4], { z16.b-z19.b }, { z20.b-z23.b }
+// CHECK-ENCODING: [0x00,0x56,0xb5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b55600 <unknown>
+
+sdot    za.s[w8, 0, vgx4], {z12.b-z15.b}, {z0.b-z3.b}  // 11000001-10100001-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11580 <unknown>
+
+sdot    za.s[w8, 0], {z12.b-z15.b}, {z0.b-z3.b}  // 11000001-10100001-00010101-10000000
+// CHECK-INST: sdot    za.s[w8, 0, vgx4], { z12.b-z15.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x80,0x15,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a11580 <unknown>
+
+sdot    za.s[w10, 1, vgx4], {z0.b-z3.b}, {z24.b-z27.b}  // 11000001-10111001-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.b-z3.b }, { z24.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xb9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b95401 <unknown>
+
+sdot    za.s[w10, 1], {z0.b-z3.b}, {z24.b-z27.b}  // 11000001-10111001-01010100-00000001
+// CHECK-INST: sdot    za.s[w10, 1, vgx4], { z0.b-z3.b }, { z24.b-z27.b }
+// CHECK-ENCODING: [0x01,0x54,0xb9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1b95401 <unknown>
+
+sdot    za.s[w8, 5, vgx4], {z20.b-z23.b}, {z28.b-z31.b}  // 11000001-10111101-00010110-10000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.b-z23.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x85,0x16,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1685 <unknown>
+
+sdot    za.s[w8, 5], {z20.b-z23.b}, {z28.b-z31.b}  // 11000001-10111101-00010110-10000101
+// CHECK-INST: sdot    za.s[w8, 5, vgx4], { z20.b-z23.b }, { z28.b-z31.b }
+// CHECK-ENCODING: [0x85,0x16,0xbd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1bd1685 <unknown>
+
+sdot    za.s[w11, 2, vgx4], {z8.b-z11.b}, {z0.b-z3.b}  // 11000001-10100001-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.b-z11.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x02,0x75,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a17502 <unknown>
+
+sdot    za.s[w11, 2], {z8.b-z11.b}, {z0.b-z3.b}  // 11000001-10100001-01110101-00000010
+// CHECK-INST: sdot    za.s[w11, 2, vgx4], { z8.b-z11.b }, { z0.b-z3.b }
+// CHECK-ENCODING: [0x02,0x75,0xa1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a17502 <unknown>
+
+sdot    za.s[w9, 7, vgx4], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a93587 <unknown>
+
+sdot    za.s[w9, 7], {z12.b-z15.b}, {z8.b-z11.b}  // 11000001-10101001-00110101-10000111
+// CHECK-INST: sdot    za.s[w9, 7, vgx4], { z12.b-z15.b }, { z8.b-z11.b }
+// CHECK-ENCODING: [0x87,0x35,0xa9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1a93587 <unknown>
+
+
+sdot    za.d[w8, 0, vgx4], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701400 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z3.h}, z0.h  // 11000001-01110000-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h
+// CHECK-ENCODING: [0x00,0x14,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701400 <unknown>
+
+sdot    za.d[w10, 5, vgx4], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z10.h-z13.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x75,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1755545 <unknown>
+
+sdot    za.d[w10, 5], {z10.h-z13.h}, z5.h  // 11000001-01110101-01010101-01000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z10.h-z13.h }, z5.h
+// CHECK-ENCODING: [0x45,0x55,0x75,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1755545 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z13.h-z16.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x78,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17875a7 <unknown>
+
+sdot    za.d[w11, 7], {z13.h-z16.h}, z8.h  // 11000001-01111000-01110101-10100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z13.h-z16.h }, z8.h
+// CHECK-ENCODING: [0xa7,0x75,0x78,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17875a7 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z31.h-z2.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x7f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17f77e7 <unknown>
+
+sdot    za.d[w11, 7], {z31.h-z2.h}, z15.h  // 11000001-01111111-01110111-11100111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z31.h-z2.h }, z15.h
+// CHECK-ENCODING: [0xe7,0x77,0x7f,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17f77e7 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z17.h-z20.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701625 <unknown>
+
+sdot    za.d[w8, 5], {z17.h-z20.h}, z0.h  // 11000001-01110000-00010110-00100101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z17.h-z20.h }, z0.h
+// CHECK-ENCODING: [0x25,0x16,0x70,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1701625 <unknown>
+
+sdot    za.d[w8, 1, vgx4], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z1.h-z4.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e1421 <unknown>
+
+sdot    za.d[w8, 1], {z1.h-z4.h}, z14.h  // 11000001-01111110-00010100-00100001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z1.h-z4.h }, z14.h
+// CHECK-ENCODING: [0x21,0x14,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e1421 <unknown>
+
+sdot    za.d[w10, 0, vgx4], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z19.h-z22.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x74,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1745660 <unknown>
+
+sdot    za.d[w10, 0], {z19.h-z22.h}, z4.h  // 11000001-01110100-01010110-01100000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z19.h-z22.h }, z4.h
+// CHECK-ENCODING: [0x60,0x56,0x74,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1745660 <unknown>
+
+sdot    za.d[w8, 0, vgx4], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x72,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1721580 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z15.h}, z2.h  // 11000001-01110010-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h
+// CHECK-ENCODING: [0x80,0x15,0x72,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1721580 <unknown>
+
+sdot    za.d[w10, 1, vgx4], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z1.h-z4.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x7a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17a5421 <unknown>
+
+sdot    za.d[w10, 1], {z1.h-z4.h}, z10.h  // 11000001-01111010-01010100-00100001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z1.h-z4.h }, z10.h
+// CHECK-ENCODING: [0x21,0x54,0x7a,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17a5421 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z22.h-z25.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e16c5 <unknown>
+
+sdot    za.d[w8, 5], {z22.h-z25.h}, z14.h  // 11000001-01111110-00010110-11000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z22.h-z25.h }, z14.h
+// CHECK-ENCODING: [0xc5,0x16,0x7e,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17e16c5 <unknown>
+
+sdot    za.d[w11, 2, vgx4], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z9.h-z12.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x71,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1717522 <unknown>
+
+sdot    za.d[w11, 2], {z9.h-z12.h}, z1.h  // 11000001-01110001-01110101-00100010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z9.h-z12.h }, z1.h
+// CHECK-ENCODING: [0x22,0x75,0x71,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1717522 <unknown>
+
+sdot    za.d[w9, 7, vgx4], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x7b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17b3587 <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z15.h}, z11.h  // 11000001-01111011-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h
+// CHECK-ENCODING: [0x87,0x35,0x7b,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c17b3587 <unknown>
+
+
+sdot    za.d[w8, 0, vgx4], {z0.h-z3.h}, z0.h[0]  // 11000001-11010000-10000000-00001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
+// CHECK-ENCODING: [0x08,0x80,0xd0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d08008 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z3.h}, z0.h[0]  // 11000001-11010000-10000000-00001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, z0.h[0]
+// CHECK-ENCODING: [0x08,0x80,0xd0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d08008 <unknown>
+
+sdot    za.d[w10, 5, vgx4], {z8.h-z11.h}, z5.h[1]  // 11000001-11010101-11000101-00001101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x0d,0xc5,0xd5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d5c50d <unknown>
+
+sdot    za.d[w10, 5], {z8.h-z11.h}, z5.h[1]  // 11000001-11010101-11000101-00001101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z8.h-z11.h }, z5.h[1]
+// CHECK-ENCODING: [0x0d,0xc5,0xd5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d5c50d <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z12.h-z15.h}, z8.h[1]  // 11000001-11011000-11100101-10001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z12.h-z15.h }, z8.h[1]
+// CHECK-ENCODING: [0x8f,0xe5,0xd8,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d8e58f <unknown>
+
+sdot    za.d[w11, 7], {z12.h-z15.h}, z8.h[1]  // 11000001-11011000-11100101-10001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z12.h-z15.h }, z8.h[1]
+// CHECK-ENCODING: [0x8f,0xe5,0xd8,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d8e58f <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z28.h-z31.h}, z15.h[1]  // 11000001-11011111-11100111-10001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z28.h-z31.h }, z15.h[1]
+// CHECK-ENCODING: [0x8f,0xe7,0xdf,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1dfe78f <unknown>
+
+sdot    za.d[w11, 7], {z28.h-z31.h}, z15.h[1]  // 11000001-11011111-11100111-10001111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z28.h-z31.h }, z15.h[1]
+// CHECK-ENCODING: [0x8f,0xe7,0xdf,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1dfe78f <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z16.h-z19.h}, z0.h[1]  // 11000001-11010000-10000110-00001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z16.h-z19.h }, z0.h[1]
+// CHECK-ENCODING: [0x0d,0x86,0xd0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d0860d <unknown>
+
+sdot    za.d[w8, 5], {z16.h-z19.h}, z0.h[1]  // 11000001-11010000-10000110-00001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z16.h-z19.h }, z0.h[1]
+// CHECK-ENCODING: [0x0d,0x86,0xd0,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d0860d <unknown>
+
+sdot    za.d[w8, 1, vgx4], {z0.h-z3.h}, z14.h[1]  // 11000001-11011110-10000100-00001001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
+// CHECK-ENCODING: [0x09,0x84,0xde,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1de8409 <unknown>
+
+sdot    za.d[w8, 1], {z0.h-z3.h}, z14.h[1]  // 11000001-11011110-10000100-00001001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z0.h-z3.h }, z14.h[1]
+// CHECK-ENCODING: [0x09,0x84,0xde,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1de8409 <unknown>
+
+sdot    za.d[w10, 0, vgx4], {z16.h-z19.h}, z4.h[1]  // 11000001-11010100-11000110-00001000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x08,0xc6,0xd4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d4c608 <unknown>
+
+sdot    za.d[w10, 0], {z16.h-z19.h}, z4.h[1]  // 11000001-11010100-11000110-00001000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z16.h-z19.h }, z4.h[1]
+// CHECK-ENCODING: [0x08,0xc6,0xd4,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d4c608 <unknown>
+
+sdot    za.d[w8, 0, vgx4], {z12.h-z15.h}, z2.h[0]  // 11000001-11010010-10000001-10001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h[0]
+// CHECK-ENCODING: [0x88,0x81,0xd2,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d28188 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z15.h}, z2.h[0]  // 11000001-11010010-10000001-10001000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, z2.h[0]
+// CHECK-ENCODING: [0x88,0x81,0xd2,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d28188 <unknown>
+
+sdot    za.d[w10, 1, vgx4], {z0.h-z3.h}, z10.h[0]  // 11000001-11011010-11000000-00001001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z0.h-z3.h }, z10.h[0]
+// CHECK-ENCODING: [0x09,0xc0,0xda,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1dac009 <unknown>
+
+sdot    za.d[w10, 1], {z0.h-z3.h}, z10.h[0]  // 11000001-11011010-11000000-00001001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z0.h-z3.h }, z10.h[0]
+// CHECK-ENCODING: [0x09,0xc0,0xda,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1dac009 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z20.h-z23.h}, z14.h[0]  // 11000001-11011110-10000010-10001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z20.h-z23.h }, z14.h[0]
+// CHECK-ENCODING: [0x8d,0x82,0xde,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1de828d <unknown>
+
+sdot    za.d[w8, 5], {z20.h-z23.h}, z14.h[0]  // 11000001-11011110-10000010-10001101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z20.h-z23.h }, z14.h[0]
+// CHECK-ENCODING: [0x8d,0x82,0xde,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1de828d <unknown>
+
+sdot    za.d[w11, 2, vgx4], {z8.h-z11.h}, z1.h[1]  // 11000001-11010001-11100101-00001010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
+// CHECK-ENCODING: [0x0a,0xe5,0xd1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d1e50a <unknown>
+
+sdot    za.d[w11, 2], {z8.h-z11.h}, z1.h[1]  // 11000001-11010001-11100101-00001010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z8.h-z11.h }, z1.h[1]
+// CHECK-ENCODING: [0x0a,0xe5,0xd1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1d1e50a <unknown>
+
+sdot    za.d[w9, 7, vgx4], {z12.h-z15.h}, z11.h[0]  // 11000001-11011011-10100001-10001111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h[0]
+// CHECK-ENCODING: [0x8f,0xa1,0xdb,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1dba18f <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z15.h}, z11.h[0]  // 11000001-11011011-10100001-10001111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, z11.h[0]
+// CHECK-ENCODING: [0x8f,0xa1,0xdb,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1dba18f <unknown>
+
+
+sdot    za.d[w8, 0, vgx4], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x00,0x14,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11400 <unknown>
+
+sdot    za.d[w8, 0], {z0.h-z3.h}, {z0.h-z3.h}  // 11000001-11100001-00010100-00000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z0.h-z3.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x00,0x14,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11400 <unknown>
+
+sdot    za.d[w10, 5, vgx4], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x05,0x55,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55505 <unknown>
+
+sdot    za.d[w10, 5], {z8.h-z11.h}, {z20.h-z23.h}  // 11000001-11110101-01010101-00000101
+// CHECK-INST: sdot    za.d[w10, 5, vgx4], { z8.h-z11.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x05,0x55,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55505 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x75,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e97587 <unknown>
+
+sdot    za.d[w11, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-01110101-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x75,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e97587 <unknown>
+
+sdot    za.d[w11, 7, vgx4], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x87,0x77,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd7787 <unknown>
+
+sdot    za.d[w11, 7], {z28.h-z31.h}, {z28.h-z31.h}  // 11000001-11111101-01110111-10000111
+// CHECK-INST: sdot    za.d[w11, 7, vgx4], { z28.h-z31.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x87,0x77,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd7787 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
+// CHECK-ENCODING: [0x05,0x16,0xf1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f11605 <unknown>
+
+sdot    za.d[w8, 5], {z16.h-z19.h}, {z16.h-z19.h}  // 11000001-11110001-00010110-00000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z16.h-z19.h }, { z16.h-z19.h }
+// CHECK-ENCODING: [0x05,0x16,0xf1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f11605 <unknown>
+
+sdot    za.d[w8, 1, vgx4], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1401 <unknown>
+
+sdot    za.d[w8, 1], {z0.h-z3.h}, {z28.h-z31.h}  // 11000001-11111101-00010100-00000001
+// CHECK-INST: sdot    za.d[w8, 1, vgx4], { z0.h-z3.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x01,0x14,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1401 <unknown>
+
+sdot    za.d[w10, 0, vgx4], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x00,0x56,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55600 <unknown>
+
+sdot    za.d[w10, 0], {z16.h-z19.h}, {z20.h-z23.h}  // 11000001-11110101-01010110-00000000
+// CHECK-INST: sdot    za.d[w10, 0, vgx4], { z16.h-z19.h }, { z20.h-z23.h }
+// CHECK-ENCODING: [0x00,0x56,0xf5,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f55600 <unknown>
+
+sdot    za.d[w8, 0, vgx4], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11580 <unknown>
+
+sdot    za.d[w8, 0], {z12.h-z15.h}, {z0.h-z3.h}  // 11000001-11100001-00010101-10000000
+// CHECK-INST: sdot    za.d[w8, 0, vgx4], { z12.h-z15.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x80,0x15,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e11580 <unknown>
+
+sdot    za.d[w10, 1, vgx4], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xf9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f95401 <unknown>
+
+sdot    za.d[w10, 1], {z0.h-z3.h}, {z24.h-z27.h}  // 11000001-11111001-01010100-00000001
+// CHECK-INST: sdot    za.d[w10, 1, vgx4], { z0.h-z3.h }, { z24.h-z27.h }
+// CHECK-ENCODING: [0x01,0x54,0xf9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1f95401 <unknown>
+
+sdot    za.d[w8, 5, vgx4], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x85,0x16,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1685 <unknown>
+
+sdot    za.d[w8, 5], {z20.h-z23.h}, {z28.h-z31.h}  // 11000001-11111101-00010110-10000101
+// CHECK-INST: sdot    za.d[w8, 5, vgx4], { z20.h-z23.h }, { z28.h-z31.h }
+// CHECK-ENCODING: [0x85,0x16,0xfd,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1fd1685 <unknown>
+
+sdot    za.d[w11, 2, vgx4], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x02,0x75,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e17502 <unknown>
+
+sdot    za.d[w11, 2], {z8.h-z11.h}, {z0.h-z3.h}  // 11000001-11100001-01110101-00000010
+// CHECK-INST: sdot    za.d[w11, 2, vgx4], { z8.h-z11.h }, { z0.h-z3.h }
+// CHECK-ENCODING: [0x02,0x75,0xe1,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e17502 <unknown>
+
+sdot    za.d[w9, 7, vgx4], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e93587 <unknown>
+
+sdot    za.d[w9, 7], {z12.h-z15.h}, {z8.h-z11.h}  // 11000001-11101001-00110101-10000111
+// CHECK-INST: sdot    za.d[w9, 7, vgx4], { z12.h-z15.h }, { z8.h-z11.h }
+// CHECK-ENCODING: [0x87,0x35,0xe9,0xc1]
+// CHECK-ERROR: instruction requires: sme2
+// CHECK-UNKNOWN: c1e93587 <unknown>