diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp
index 15b9510b0f4b60..d2c52a294543cb 100644
--- a/src/coreclr/jit/hwintrinsicarm64.cpp
+++ b/src/coreclr/jit/hwintrinsicarm64.cpp
@@ -1745,7 +1745,11 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
         }
 
         case NI_AdvSimd_StoreVector64x2:
+        case NI_AdvSimd_StoreVector64x3:
+        case NI_AdvSimd_StoreVector64x4:
         case NI_AdvSimd_Arm64_StoreVector128x2:
+        case NI_AdvSimd_Arm64_StoreVector128x3:
+        case NI_AdvSimd_Arm64_StoreVector128x4:
         {
             assert(sig->numArgs == 2);
             assert(retType == TYP_VOID);
diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp
index 57df941c5fe685..2de48df5980f1b 100644
--- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp
+++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp
@@ -797,7 +797,11 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node)
                 break;
 
             case NI_AdvSimd_StoreVector64x2:
+            case NI_AdvSimd_StoreVector64x3:
+            case NI_AdvSimd_StoreVector64x4:
             case NI_AdvSimd_Arm64_StoreVector128x2:
+            case NI_AdvSimd_Arm64_StoreVector128x3:
+            case NI_AdvSimd_Arm64_StoreVector128x4:
             {
                 unsigned regCount = 0;
 
@@ -817,7 +821,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node)
                     assert(argReg == argNode->GetRegNum());
                     argReg = REG_NEXT(argReg);
                 }
-                assert(regCount == 2);
+                assert((ins == INS_st1_2regs && regCount == 2) || (ins == INS_st1_3regs && regCount == 3) ||
+                       (ins == INS_st1_4regs && regCount == 4));
 #endif
 
                 GetEmitter()->emitIns_R_R(ins, emitSize, op2Reg, op1Reg, opt);
diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h
index f0a0529e5e64c3..773e7726ee8ef5 100644
--- a/src/coreclr/jit/hwintrinsiclistarm64.h
+++ b/src/coreclr/jit/hwintrinsiclistarm64.h
@@ -479,7 +479,9 @@ HARDWARE_INTRINSIC(AdvSimd,       SignExtendWideningUpper,
 HARDWARE_INTRINSIC(AdvSimd,       SqrtScalar,                                                        8,      1,      true,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_fsqrt,          INS_fsqrt},       HW_Category_SIMD,                  HW_Flag_SIMDScalar)
 HARDWARE_INTRINSIC(AdvSimd,       Store,                                                            -1,      2,      true,  {INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1},         HW_Category_Helper,                HW_Flag_SpecialImport|HW_Flag_BaseTypeFromSecondArg|HW_Flag_NoCodeGen)
 HARDWARE_INTRINSIC(AdvSimd,       StoreSelectedScalar,                                              -1,      3,      true,  {INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1,            INS_st1},         HW_Category_MemoryStore,           HW_Flag_BaseTypeFromSecondArg|HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen)
-HARDWARE_INTRINSIC(AdvSimd,       StoreVector64x2,                                                   8,      2,      true,  {INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_invalid,        INS_invalid,        INS_st2,            INS_invalid},     HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
+HARDWARE_INTRINSIC(AdvSimd,       StoreVector64x2,                                                   8,      2,      true,  {INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,            INS_invalid,        INS_invalid,  INS_st1_2regs,      INS_invalid},     HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
+HARDWARE_INTRINSIC(AdvSimd,       StoreVector64x3,                                                   8,      2,      true,  {INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,            INS_invalid,        INS_invalid,  INS_st1_3regs,      INS_invalid},     HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
+HARDWARE_INTRINSIC(AdvSimd,       StoreVector64x4,                                                   8,      2,      true,  {INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,            INS_invalid,        INS_invalid,  INS_st1_4regs,      INS_invalid},     HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
 HARDWARE_INTRINSIC(AdvSimd,       Subtract,                                                         -1,      2,      true,  {INS_sub,            INS_sub,            INS_sub,            INS_sub,            INS_sub,            INS_sub,            INS_sub,            INS_sub,            INS_fsub,           INS_invalid},     HW_Category_SIMD,                  HW_Flag_NoFlag)
 HARDWARE_INTRINSIC(AdvSimd,       SubtractHighNarrowingLower,                                        8,      2,      true,  {INS_subhn,          INS_subhn,          INS_subhn,          INS_subhn,          INS_subhn,          INS_subhn,          INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_SIMD,                  HW_Flag_NoFlag)
 HARDWARE_INTRINSIC(AdvSimd,       SubtractHighNarrowingUpper,                                       16,      3,      true,  {INS_subhn2,         INS_subhn2,         INS_subhn2,         INS_subhn2,         INS_subhn2,         INS_subhn2,         INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_SIMD,                  HW_Flag_HasRMWSemantics)
@@ -671,7 +673,9 @@ HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePair,
 HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePairScalar,                                                   8,      3,      true,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_stp,            INS_stp,            INS_invalid,        INS_invalid,        INS_stp,            INS_invalid},     HW_Category_MemoryStore,           HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen)
 HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePairScalarNonTemporal,                                        8,      3,      true,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_stnp,           INS_stnp,           INS_invalid,        INS_invalid,        INS_stnp,           INS_invalid},     HW_Category_MemoryStore,           HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen)
 HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePairNonTemporal,                                             -1,      3,      true,  {INS_stnp,           INS_stnp,           INS_stnp,           INS_stnp,           INS_stnp,           INS_stnp,           INS_stnp,           INS_stnp,           INS_stnp,           INS_stp},         HW_Category_MemoryStore,           HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen)
-HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreVector128x2,                                                 16,      2,      true,  {INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2,            INS_st2},         HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
+HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreVector128x2,                                                 16,      2,      true,  {INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs,      INS_st1_2regs},   HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
+HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreVector128x3,                                                 16,      2,      true,  {INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs,      INS_st1_3regs},   HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
+HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreVector128x4,                                                 16,      2,      true,  {INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs,      INS_st1_4regs},   HW_Category_MemoryStore,           HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters)
 HARDWARE_INTRINSIC(AdvSimd_Arm64, Subtract,                                                         16,      2,     false,  {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_fsub},        HW_Category_SIMD,                  HW_Flag_NoFlag)
 HARDWARE_INTRINSIC(AdvSimd_Arm64, SubtractSaturateScalar,                                            8,      2,      true,  {INS_sqsub,          INS_uqsub,          INS_sqsub,          INS_uqsub,          INS_sqsub,          INS_uqsub,          INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_SIMD,                  HW_Flag_SIMDScalar)
 HARDWARE_INTRINSIC(AdvSimd_Arm64, TransposeEven,                                                    -1,      2,      true,  {INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1,           INS_trn1},        HW_Category_SIMD,                  HW_Flag_NoFlag)
diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp
index e1907d4a3fa55e..5c84c5c62bf1ba 100644
--- a/src/coreclr/jit/lsraarm64.cpp
+++ b/src/coreclr/jit/lsraarm64.cpp
@@ -1608,7 +1608,11 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree, int* pDstCou
                 *pDstCount = 1;
                 break;
             case NI_AdvSimd_StoreVector64x2:
+            case NI_AdvSimd_StoreVector64x3:
+            case NI_AdvSimd_StoreVector64x4:
             case NI_AdvSimd_Arm64_StoreVector128x2:
+            case NI_AdvSimd_Arm64_StoreVector128x3:
+            case NI_AdvSimd_Arm64_StoreVector128x4:
                 assert(intrin.op1 != nullptr);
                 srcCount += BuildConsecutiveRegistersForUse(intrin.op2);
                 assert(dstCount == 0);
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
index 500960104fb4a0..c811950d7aa80d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs
@@ -2099,302 +2099,302 @@ internal Arm64() { }
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadPairVector128NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2AndUnzip(byte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2AndUnzip(short* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2AndUnzip(int* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2AndUnzip(long* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2AndUnzip(float* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2AndUnzip(double* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3AndUnzip(byte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3AndUnzip(short* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3AndUnzip(int* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3AndUnzip(long* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3AndUnzip(float* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3AndUnzip(double* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4AndUnzip(byte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4AndUnzip(short* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4AndUnzip(int* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4AndUnzip(long* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4AndUnzip(float* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4AndUnzip(double* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2(byte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2(sbyte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2(short* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2(ushort* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2(int* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2(uint* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2(long* address)  { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2(float* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2(double* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3(byte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3(sbyte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3(short* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3(ushort* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3(int* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3(uint* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3(long* address)  { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3(float* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3(double* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4(byte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4(sbyte* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4(short* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4(ushort* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4(int* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4(uint* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4(long* address)  { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4(ulong* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4(float* address) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4(double* address) { throw new PlatformNotSupportedException(); }
 
@@ -3777,55 +3777,155 @@ internal Arm64() { }
             public static unsafe void StorePairScalarNonTemporal(uint* address, Vector64<uint> value1, Vector64<uint> value2) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: ST1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: ST1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: ST1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(short* address, (Vector128<short> Value1, Vector128<short> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: ST1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: ST1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(int* address, (Vector128<int> Value1, Vector128<int> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: ST1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///    A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///    A64: ST1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(long* address, (Vector128<long> Value1, Vector128<long> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: ST1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: ST1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(float* address, (Vector128<float> Value1, Vector128<float> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: ST1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(double* address, (Vector128<double> Value1, Vector128<double> Value2) value) { throw new PlatformNotSupportedException(); }
 
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value) { throw new PlatformNotSupportedException(); }
+
             /// <summary>
             /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b)
             ///   A64: FSUB Vd.2D, Vn.2D, Vm.2D
@@ -9188,212 +9288,212 @@ internal Arm64() { }
         public static unsafe Vector128<ulong> LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2AndUnzip(byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2AndUnzip(short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2AndUnzip(int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2AndUnzip(float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3AndUnzip(byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3AndUnzip(short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3AndUnzip(int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3AndUnzip(float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4AndUnzip(byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4AndUnzip(short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4AndUnzip(int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4AndUnzip(float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2(byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2(sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2(short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2(ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2(int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2(float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3(byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3(sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3(short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3(ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3(int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3(float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4(byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4(sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4(short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4(ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4(int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4(float* address) { throw new PlatformNotSupportedException(); }
 
@@ -15508,40 +15608,110 @@ internal Arm64() { }
         public static unsafe void StoreSelectedScalar(ulong* address, Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: ST1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: ST1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: ST1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(short* address, (Vector64<short> Value1, Vector64<short> Value2) value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: ST1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: ST1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(int* address, (Vector64<int> Value1, Vector64<int> Value2) value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: ST1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: ST1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(float* address, (Vector64<float> Value1, Vector64<float> Value2) value) { throw new PlatformNotSupportedException(); }
 
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value) { throw new PlatformNotSupportedException(); }
+
         /// <summary>
         /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b)
         ///   A32: VSUB.I8 Dd, Dn, Dm
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs
index afd09b1307a68a..7d0befac8e95ed 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs
@@ -2097,302 +2097,302 @@ internal Arm64() { }
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadPairVector128NonTemporal(ulong* address) => LoadPairVector128NonTemporal(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2AndUnzip(byte* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2AndUnzip(sbyte* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2AndUnzip(short* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2AndUnzip(ushort* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2AndUnzip(int* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2AndUnzip(uint* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2AndUnzip(long* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2AndUnzip(ulong* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2AndUnzip(float* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2AndUnzip(double* address) => LoadVector128x2AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3AndUnzip(byte* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3AndUnzip(sbyte* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3AndUnzip(short* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3AndUnzip(ushort* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3AndUnzip(int* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3AndUnzip(uint* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3AndUnzip(long* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3AndUnzip(ulong* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3AndUnzip(float* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3AndUnzip(double* address) => LoadVector128x3AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4AndUnzip(byte* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4AndUnzip(sbyte* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4AndUnzip(short* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4AndUnzip(ushort* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4AndUnzip(int* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4AndUnzip(uint* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4AndUnzip(long* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4AndUnzip(ulong* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4AndUnzip(float* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4AndUnzip(double* address) => LoadVector128x4AndUnzip(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2) LoadVector128x2(byte* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2) LoadVector128x2(sbyte* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2) LoadVector128x2(short* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2) LoadVector128x2(ushort* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2) LoadVector128x2(int* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2) LoadVector128x2(uint* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2) LoadVector128x2(long* address)  => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2) LoadVector128x2(ulong* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2) LoadVector128x2(float* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2) LoadVector128x2(double* address) => LoadVector128x2(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) LoadVector128x3(byte* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) LoadVector128x3(sbyte* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) LoadVector128x3(short* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) LoadVector128x3(ushort* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) LoadVector128x3(int* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) LoadVector128x3(uint* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) LoadVector128x3(long* address)  => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) LoadVector128x3(ulong* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) LoadVector128x3(float* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) LoadVector128x3(double* address) => LoadVector128x3(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) LoadVector128x4(byte* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            ///   A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
             /// </summary>
             public static unsafe (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) LoadVector128x4(sbyte* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) LoadVector128x4(short* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            ///   A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
             /// </summary>
             public static unsafe (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) LoadVector128x4(ushort* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) LoadVector128x4(int* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) LoadVector128x4(uint* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) LoadVector128x4(long* address)  => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn]
             /// </summary>
             public static unsafe (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) LoadVector128x4(ulong* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
             /// </summary>
             public static unsafe (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) LoadVector128x4(float* address) => LoadVector128x4(address);
 
             /// <summary>
-            ///   A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            ///   A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
             /// </summary>
             public static unsafe (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) LoadVector128x4(double* address) => LoadVector128x4(address);
 
@@ -3775,55 +3775,155 @@ internal Arm64() { }
             public static unsafe void StorePairScalarNonTemporal(uint* address, Vector64<uint> value1, Vector64<uint> value2) => StorePairScalarNonTemporal(address, value1, value2);
 
             /// <summary>
-            ///   A64: ST2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: ST1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.16B, Vn+1.16B }, [Xn]
+            ///   A64: ST1 { Vn.16B, Vn+1.16B }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: ST1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(short* address, (Vector128<short> Value1, Vector128<short> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.8H, Vn+1.8H }, [Xn]
+            ///   A64: ST1 { Vn.8H, Vn+1.8H }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: ST1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(int* address, (Vector128<int> Value1, Vector128<int> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: ST1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: ST1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(long* address, (Vector128<long> Value1, Vector128<long> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: ST1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.4S, Vn+1.4S }, [Xn]
+            ///   A64: ST1 { Vn.4S, Vn+1.4S }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(float* address, (Vector128<float> Value1, Vector128<float> Value2) value) => StoreVector128x2(address, value);
 
             /// <summary>
-            ///   A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: ST1 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2(double* address, (Vector128<double> Value1, Vector128<double> Value2) value) => StoreVector128x2(address, value);
 
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x3(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3) value) => StoreVector128x3(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(byte* address, (Vector128<byte> Value1, Vector128<byte> Value2, Vector128<byte> Value3, Vector128<byte> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(sbyte* address, (Vector128<sbyte> Value1, Vector128<sbyte> Value2, Vector128<sbyte> Value3, Vector128<sbyte> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(short* address, (Vector128<short> Value1, Vector128<short> Value2, Vector128<short> Value3, Vector128<short> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(ushort* address, (Vector128<ushort> Value1, Vector128<ushort> Value2, Vector128<ushort> Value3, Vector128<ushort> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(int* address, (Vector128<int> Value1, Vector128<int> Value2, Vector128<int> Value3, Vector128<int> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2, Vector128<uint> Value3, Vector128<uint> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(long* address, (Vector128<long> Value1, Vector128<long> Value2, Vector128<long> Value3, Vector128<long> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(ulong* address, (Vector128<ulong> Value1, Vector128<ulong> Value2, Vector128<ulong> Value3, Vector128<ulong> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(float* address, (Vector128<float> Value1, Vector128<float> Value2, Vector128<float> Value3, Vector128<float> Value4) value) => StoreVector128x4(address, value);
+
+            /// <summary>
+            ///   A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn]
+            /// </summary>
+            public static unsafe void StoreVector128x4(double* address, (Vector128<double> Value1, Vector128<double> Value2, Vector128<double> Value3, Vector128<double> Value4) value) => StoreVector128x4(address, value);
+
             /// <summary>
             /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b)
             ///   A64: FSUB Vd.2D, Vn.2D, Vm.2D
@@ -9185,212 +9285,212 @@ internal Arm64() { }
         public static unsafe Vector128<ulong> LoadVector128(ulong* address) => LoadVector128(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2AndUnzip(byte* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2AndUnzip(sbyte* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2AndUnzip(short* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2AndUnzip(ushort* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2AndUnzip(int* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2AndUnzip(uint* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2AndUnzip(float* address) => LoadVector64x2AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3AndUnzip(byte* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3AndUnzip(sbyte* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3AndUnzip(short* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3AndUnzip(ushort* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3AndUnzip(int* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3AndUnzip(uint* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3AndUnzip(float* address) => LoadVector64x3AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4AndUnzip(byte* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4AndUnzip(sbyte* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4AndUnzip(short* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4AndUnzip(ushort* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4AndUnzip(int* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4AndUnzip(uint* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.2S }, [Xn]
+        ///   A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4AndUnzip(float* address) => LoadVector64x4AndUnzip(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2) LoadVector64x2(byte* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2) LoadVector64x2(sbyte* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2) LoadVector64x2(short* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2) LoadVector64x2(ushort* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2) LoadVector64x2(int* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2) LoadVector64x2(uint* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2) LoadVector64x2(float* address) => LoadVector64x2(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) LoadVector64x3(byte* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) LoadVector64x3(sbyte* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) LoadVector64x3(short* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) LoadVector64x3(ushort* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) LoadVector64x3(int* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) LoadVector64x3(uint* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) LoadVector64x3(float* address) => LoadVector64x3(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) LoadVector64x4(byte* address) => LoadVector64x4(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        ///   A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
         /// </summary>
         public static unsafe (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) LoadVector64x4(sbyte* address) => LoadVector64x4(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) LoadVector64x4(short* address) => LoadVector64x4(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        ///   A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
         /// </summary>
         public static unsafe (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) LoadVector64x4(ushort* address) => LoadVector64x4(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) LoadVector64x4(int* address) => LoadVector64x4(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4(uint* address) => LoadVector64x4(address);
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        ///   A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
         /// </summary>
         public static unsafe (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) LoadVector64x4(float* address) => LoadVector64x4(address);
 
@@ -15505,40 +15605,110 @@ internal Arm64() { }
         public static unsafe void StoreSelectedScalar(ulong* address, Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
-        ///   A64: ST2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: ST1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2) value) => StoreVector64x2(address, value);
 
         /// <summary>
-        ///   A64: ST2 { Vn.8B, Vn+1.8B }, [Xn]
+        ///   A64: ST1 { Vn.8B, Vn+1.8B }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2) value) => StoreVector64x2(address, value);
 
         /// <summary>
-        ///   A64: ST2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: ST1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(short* address, (Vector64<short> Value1, Vector64<short> Value2) value) => StoreVector64x2(address, value);
 
         /// <summary>
-        ///   A64: ST2 { Vn.4H, Vn+1.4H }, [Xn]
+        ///   A64: ST1 { Vn.4H, Vn+1.4H }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2) value) => StoreVector64x2(address, value);
 
         /// <summary>
-        ///   A64: ST2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: ST1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(int* address, (Vector64<int> Value1, Vector64<int> Value2) value) => StoreVector64x2(address, value);
 
         /// <summary>
-        ///   A64: ST2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: ST1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2) value) => StoreVector64x2(address, value);
 
         /// <summary>
-        ///   A64: ST2 { Vn.2S, Vn+1.2S }, [Xn]
+        ///   A64: ST1 { Vn.2S, Vn+1.2S }, [Xn]
         /// </summary>
         public static unsafe void StoreVector64x2(float* address, (Vector64<float> Value1, Vector64<float> Value2) value) => StoreVector64x2(address, value);
 
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x3(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3) value) => StoreVector64x3(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(byte* address, (Vector64<byte> Value1, Vector64<byte> Value2, Vector64<byte> Value3, Vector64<byte> Value4) value) => StoreVector64x4(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(sbyte* address, (Vector64<sbyte> Value1, Vector64<sbyte> Value2, Vector64<sbyte> Value3, Vector64<sbyte> Value4) value) => StoreVector64x4(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(short* address, (Vector64<short> Value1, Vector64<short> Value2, Vector64<short> Value3, Vector64<short> Value4) value) => StoreVector64x4(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(ushort* address, (Vector64<ushort> Value1, Vector64<ushort> Value2, Vector64<ushort> Value3, Vector64<ushort> Value4) value) => StoreVector64x4(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(int* address, (Vector64<int> Value1, Vector64<int> Value2, Vector64<int> Value3, Vector64<int> Value4) value) => StoreVector64x4(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(uint* address, (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) value) => StoreVector64x4(address, value);
+
+        /// <summary>
+        ///   A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn]
+        /// </summary>
+        public static unsafe void StoreVector64x4(float* address, (Vector64<float> Value1, Vector64<float> Value2, Vector64<float> Value3, Vector64<float> Value4) value) => StoreVector64x4(address, value);
+
         /// <summary>
         /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b)
         ///   A32: VSUB.I8 Dd, Dn, Dm
diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
index e0f07a1441e248..c4c96e9f5babbd 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -2879,6 +2879,20 @@ public static unsafe void StoreSelectedScalar(ulong* address, System.Runtime.Int
         public unsafe static void StoreVector64x2(int* address, (System.Runtime.Intrinsics.Vector64<int> Value1, System.Runtime.Intrinsics.Vector64<int> Value2) value) { throw null; }
         public unsafe static void StoreVector64x2(uint* address, (System.Runtime.Intrinsics.Vector64<uint> Value1, System.Runtime.Intrinsics.Vector64<uint> Value2) value) { throw null; }
         public unsafe static void StoreVector64x2(float* address, (System.Runtime.Intrinsics.Vector64<float> Value1, System.Runtime.Intrinsics.Vector64<float> Value2) value) { throw null; }
+        public static unsafe void StoreVector64x3(byte* address, (System.Runtime.Intrinsics.Vector64<byte> Value1, System.Runtime.Intrinsics.Vector64<byte> Value2, System.Runtime.Intrinsics.Vector64<byte> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x3(sbyte* address, (System.Runtime.Intrinsics.Vector64<sbyte> Value1, System.Runtime.Intrinsics.Vector64<sbyte> Value2, System.Runtime.Intrinsics.Vector64<sbyte> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x3(short* address, (System.Runtime.Intrinsics.Vector64<short> Value1, System.Runtime.Intrinsics.Vector64<short> Value2, System.Runtime.Intrinsics.Vector64<short> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x3(ushort* address, (System.Runtime.Intrinsics.Vector64<ushort> Value1, System.Runtime.Intrinsics.Vector64<ushort> Value2, System.Runtime.Intrinsics.Vector64<ushort> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x3(int* address, (System.Runtime.Intrinsics.Vector64<int> Value1, System.Runtime.Intrinsics.Vector64<int> Value2, System.Runtime.Intrinsics.Vector64<int> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x3(uint* address, (System.Runtime.Intrinsics.Vector64<uint> Value1, System.Runtime.Intrinsics.Vector64<uint> Value2, System.Runtime.Intrinsics.Vector64<uint> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x3(float* address, (System.Runtime.Intrinsics.Vector64<float> Value1, System.Runtime.Intrinsics.Vector64<float> Value2, System.Runtime.Intrinsics.Vector64<float> Value3) value) { throw null; }
+        public static unsafe void StoreVector64x4(byte* address, (System.Runtime.Intrinsics.Vector64<byte> Value1, System.Runtime.Intrinsics.Vector64<byte> Value2, System.Runtime.Intrinsics.Vector64<byte> Value3, System.Runtime.Intrinsics.Vector64<byte> Value4) value) { throw null; }
+        public static unsafe void StoreVector64x4(sbyte* address, (System.Runtime.Intrinsics.Vector64<sbyte> Value1, System.Runtime.Intrinsics.Vector64<sbyte> Value2, System.Runtime.Intrinsics.Vector64<sbyte> Value3, System.Runtime.Intrinsics.Vector64<sbyte> Value4) value) { throw null; }
+        public static unsafe void StoreVector64x4(short* address, (System.Runtime.Intrinsics.Vector64<short> Value1, System.Runtime.Intrinsics.Vector64<short> Value2, System.Runtime.Intrinsics.Vector64<short> Value3, System.Runtime.Intrinsics.Vector64<short> Value4) value) { throw null; }
+        public static unsafe void StoreVector64x4(ushort* address, (System.Runtime.Intrinsics.Vector64<ushort> Value1, System.Runtime.Intrinsics.Vector64<ushort> Value2, System.Runtime.Intrinsics.Vector64<ushort> Value3, System.Runtime.Intrinsics.Vector64<ushort> Value4) value) { throw null; }
+        public static unsafe void StoreVector64x4(int* address, (System.Runtime.Intrinsics.Vector64<int> Value1, System.Runtime.Intrinsics.Vector64<int> Value2, System.Runtime.Intrinsics.Vector64<int> Value3, System.Runtime.Intrinsics.Vector64<int> Value4) value) { throw null; }
+        public static unsafe void StoreVector64x4(uint* address, (System.Runtime.Intrinsics.Vector64<uint> Value1, System.Runtime.Intrinsics.Vector64<uint> Value2, System.Runtime.Intrinsics.Vector64<uint> Value3, System.Runtime.Intrinsics.Vector64<uint> Value4) value) { throw null; }
+        public static unsafe void StoreVector64x4(float* address, (System.Runtime.Intrinsics.Vector64<float> Value1, System.Runtime.Intrinsics.Vector64<float> Value2, System.Runtime.Intrinsics.Vector64<float> Value3, System.Runtime.Intrinsics.Vector64<float> Value4) value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> Subtract(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> Subtract(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> Subtract(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
@@ -3666,7 +3680,27 @@ public static unsafe void StorePairScalarNonTemporal(uint* address, System.Runti
             public unsafe static void StoreVector128x2(long* address, (System.Runtime.Intrinsics.Vector128<long> Value1, System.Runtime.Intrinsics.Vector128<long> Value2) value) { throw null; }
             public unsafe static void StoreVector128x2(ulong* address, (System.Runtime.Intrinsics.Vector128<ulong> Value1, System.Runtime.Intrinsics.Vector128<ulong> Value2) value) { throw null; }
             public unsafe static void StoreVector128x2(float* address, (System.Runtime.Intrinsics.Vector128<float> Value1, System.Runtime.Intrinsics.Vector128<float> Value2) value) { throw null; }
-            public unsafe static void StoreVector128x2(double* address, (System.Runtime.Intrinsics.Vector128<double> Value1, System.Runtime.Intrinsics.Vector128<double> Value2) value) { throw null; }            
+            public unsafe static void StoreVector128x2(double* address, (System.Runtime.Intrinsics.Vector128<double> Value1, System.Runtime.Intrinsics.Vector128<double> Value2) value) { throw null; }
+            public static unsafe void StoreVector128x3(byte* address, (System.Runtime.Intrinsics.Vector128<byte> Value1, System.Runtime.Intrinsics.Vector128<byte> Value2, System.Runtime.Intrinsics.Vector128<byte> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(sbyte* address, (System.Runtime.Intrinsics.Vector128<sbyte> Value1, System.Runtime.Intrinsics.Vector128<sbyte> Value2, System.Runtime.Intrinsics.Vector128<sbyte> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(short* address, (System.Runtime.Intrinsics.Vector128<short> Value1, System.Runtime.Intrinsics.Vector128<short> Value2, System.Runtime.Intrinsics.Vector128<short> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(ushort* address, (System.Runtime.Intrinsics.Vector128<ushort> Value1, System.Runtime.Intrinsics.Vector128<ushort> Value2, System.Runtime.Intrinsics.Vector128<ushort> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(int* address, (System.Runtime.Intrinsics.Vector128<int> Value1, System.Runtime.Intrinsics.Vector128<int> Value2, System.Runtime.Intrinsics.Vector128<int> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(uint* address, (System.Runtime.Intrinsics.Vector128<uint> Value1, System.Runtime.Intrinsics.Vector128<uint> Value2, System.Runtime.Intrinsics.Vector128<uint> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(long* address, (System.Runtime.Intrinsics.Vector128<long> Value1, System.Runtime.Intrinsics.Vector128<long> Value2, System.Runtime.Intrinsics.Vector128<long> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(ulong* address, (System.Runtime.Intrinsics.Vector128<ulong> Value1, System.Runtime.Intrinsics.Vector128<ulong> Value2, System.Runtime.Intrinsics.Vector128<ulong> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(float* address, (System.Runtime.Intrinsics.Vector128<float> Value1, System.Runtime.Intrinsics.Vector128<float> Value2, System.Runtime.Intrinsics.Vector128<float> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x3(double* address, (System.Runtime.Intrinsics.Vector128<double> Value1, System.Runtime.Intrinsics.Vector128<double> Value2, System.Runtime.Intrinsics.Vector128<double> Value3) value) { throw null; }
+            public static unsafe void StoreVector128x4(byte* address, (System.Runtime.Intrinsics.Vector128<byte> Value1, System.Runtime.Intrinsics.Vector128<byte> Value2, System.Runtime.Intrinsics.Vector128<byte> Value3, System.Runtime.Intrinsics.Vector128<byte> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(sbyte* address, (System.Runtime.Intrinsics.Vector128<sbyte> Value1, System.Runtime.Intrinsics.Vector128<sbyte> Value2, System.Runtime.Intrinsics.Vector128<sbyte> Value3, System.Runtime.Intrinsics.Vector128<sbyte> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(short* address, (System.Runtime.Intrinsics.Vector128<short> Value1, System.Runtime.Intrinsics.Vector128<short> Value2, Vector128<short> Value3, System.Runtime.Intrinsics.Vector128<short> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(ushort* address, (System.Runtime.Intrinsics.Vector128<ushort> Value1, System.Runtime.Intrinsics.Vector128<ushort> Value2, System.Runtime.Intrinsics.Vector128<ushort> Value3, System.Runtime.Intrinsics.Vector128<ushort> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(int* address, (System.Runtime.Intrinsics.Vector128<int> Value1, System.Runtime.Intrinsics.Vector128<int> Value2, System.Runtime.Intrinsics.Vector128<int> Value3, System.Runtime.Intrinsics.Vector128<int> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(uint* address, (System.Runtime.Intrinsics.Vector128<uint> Value1, System.Runtime.Intrinsics.Vector128<uint> Value2, System.Runtime.Intrinsics.Vector128<uint> Value3, System.Runtime.Intrinsics.Vector128<uint> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(long* address, (System.Runtime.Intrinsics.Vector128<long> Value1, System.Runtime.Intrinsics.Vector128<long> Value2, System.Runtime.Intrinsics.Vector128<long> Value3, System.Runtime.Intrinsics.Vector128<long> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(ulong* address, (System.Runtime.Intrinsics.Vector128<ulong> Value1, System.Runtime.Intrinsics.Vector128<ulong> Value2, System.Runtime.Intrinsics.Vector128<ulong> Value3, System.Runtime.Intrinsics.Vector128<ulong> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(float* address, (System.Runtime.Intrinsics.Vector128<float> Value1, System.Runtime.Intrinsics.Vector128<float> Value2, System.Runtime.Intrinsics.Vector128<float> Value3, System.Runtime.Intrinsics.Vector128<float> Value4) value) { throw null; }
+            public static unsafe void StoreVector128x4(double* address, (System.Runtime.Intrinsics.Vector128<double> Value1, System.Runtime.Intrinsics.Vector128<double> Value2, System.Runtime.Intrinsics.Vector128<double> Value3, System.Runtime.Intrinsics.Vector128<double> Value4) value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> Subtract(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<byte> SubtractSaturateScalar(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> SubtractSaturateScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
diff --git a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs
index 5de788f4c98423..03c3ce5f1dd5bd 100644
--- a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs
+++ b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs
@@ -1702,13 +1702,27 @@
     ("StoreSelectedScalarTest.template",  new Dictionary<string, string> { ["TestName"] = "StoreSelectedScalar_Vector128_UInt16_7",                                                                ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreSelectedScalar",                                                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16",                                                                                                                           ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()",        ["ElementIndex"] = "7",                                                                                                                       ["ValidateResult"] = "firstOp[ElementIndex] != result"}),
     ("StoreSelectedScalarTest.template",  new Dictionary<string, string> { ["TestName"] = "StoreSelectedScalar_Vector128_UInt32_3",                                                                ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreSelectedScalar",                                                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32",                                                                                                                           ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()",        ["ElementIndex"] = "3",                                                                                                                       ["ValidateResult"] = "firstOp[ElementIndex] != result"}),
     ("StoreSelectedScalarTest.template",  new Dictionary<string, string> { ["TestName"] = "StoreSelectedScalar_Vector128_UInt64_1",                                                                ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreSelectedScalar",                                                  ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64",                                                                                                                           ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()",        ["ElementIndex"] = "1",                                                                                                                       ["ValidateResult"] = "firstOp[ElementIndex] != result"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2SByte",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "SByte",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Byte",                                                                                   ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Byte",                                                                ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2UShort",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt16",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Short",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int16",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2UInt32",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt32",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Int32",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int32",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Float",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "float",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2SByte",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "SByte",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Byte",                                                                                   ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Byte",                                                                ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2UShort",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt16",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Short",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int16",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2UInt32",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt32",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Int32",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int32",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x2Float",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x2",                                                                                                                                                     ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "float",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3SByte",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "SByte",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3Byte",                                                                                   ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Byte",                                                                ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3UShort",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt16",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3Short",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int16",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3UInt32",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt32",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3Int32",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int32",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x3Float",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x3",                                                                                                                                                     ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "float",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4SByte",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "SByte",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4Byte",                                                                                   ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Byte",                                                                ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4UShort",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt16",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4Short",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int16",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4UInt32",                                                                                 ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "UInt32",                                                              ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4Int32",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int32",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector64x4Float",                                                                                  ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector64x4",                                                                                                                                                     ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "float",                                                               ["LargestVectorSize"] = "8",                                                                 ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
     ("VecBinOpTest.template",             new Dictionary<string, string> { ["TestName"] = "Subtract_Vector64_Byte",                                                                                ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract",                                                             ["RetVectorType"] = "Vector64",  ["RetBaseType"] = "Byte",    ["Op1VectorType"] = "Vector64",  ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Byte",                                                                ["LargestVectorSize"] = "8",  ["NextValueOp1"] = "TestLibrary.Generator.GetByte()",          ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "Helpers.Subtract(left[i], right[i]) != result[i]"}),
     ("VecBinOpTest.template",             new Dictionary<string, string> { ["TestName"] = "Subtract_Vector64_Int16",                                                                               ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract",                                                             ["RetVectorType"] = "Vector64",  ["RetBaseType"] = "Int16",   ["Op1VectorType"] = "Vector64",  ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int16",                                                               ["LargestVectorSize"] = "8",  ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()",         ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "Helpers.Subtract(left[i], right[i]) != result[i]"}),
     ("VecBinOpTest.template",             new Dictionary<string, string> { ["TestName"] = "Subtract_Vector64_Int32",                                                                               ["Isa"] = "AdvSimd",       ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract",                                                             ["RetVectorType"] = "Vector64",  ["RetBaseType"] = "Int32",   ["Op1VectorType"] = "Vector64",  ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int32",                                                               ["LargestVectorSize"] = "8",  ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()",         ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "Helpers.Subtract(left[i], right[i]) != result[i]"}),
@@ -2486,16 +2500,36 @@
     ("StoreBinOpTest.template",           new Dictionary<string, string> { ["TestName"] = "StorePairNonTemporal_Vector128_UInt16",                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StorePairNonTemporal",                                                                                             ["RetBaseType"] = "UInt16",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                   ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()",        ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "Helpers.Concat(firstOp, secondOp, i) != result[i]"}),
     ("StoreBinOpTest.template",           new Dictionary<string, string> { ["TestName"] = "StorePairNonTemporal_Vector128_UInt32",                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StorePairNonTemporal",                                                                                             ["RetBaseType"] = "UInt32",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                   ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()",        ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "Helpers.Concat(firstOp, secondOp, i) != result[i]"}),
     ("StoreBinOpTest.template",           new Dictionary<string, string> { ["TestName"] = "StorePairNonTemporal_Vector128_UInt64",                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StorePairNonTemporal",                                                                                             ["RetBaseType"] = "UInt64",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                   ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()",        ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()",                                                                                       ["ValidateIterResult"] = "Helpers.Concat(firstOp, secondOp, i) != result[i]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2SByte",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Byte",                                                                                  ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                     ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2UShort",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Short",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2UInt32",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Int32",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2UInt64",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Int64",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Float",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "float",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
-    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Double",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "double",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i * 2] || input2[i] != result[(i * 2) + 1]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2SByte",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Byte",                                                                                  ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                     ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2UShort",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Short",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2UInt32",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Int32",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2UInt64",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Int64",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Float",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "float",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx2Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x2Double",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x2",                                                                                                                                                               ["Op1BaseType"] = "double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "double",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3SByte",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3Byte",                                                                                  ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                     ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3UShort",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3Short",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3UInt32",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3Int32",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3UInt64",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3Int64",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3Float",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "float",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx3Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x3Double",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x3",                                                                                                                                                               ["Op1BaseType"] = "double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "double",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4SByte",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "SByte",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "SByte",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4Byte",                                                                                  ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Byte",                                                     ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4UShort",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4Short",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int16",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4UInt32",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4Int32",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "Int32",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int32",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4UInt64",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4Int64",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "Int64",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Int64",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()",                                                                                        ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4Float",                                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "float",  ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "float",                                                    ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
+    ("StoreVectorx4Test.template",        new Dictionary<string, string> { ["TestName"] = "StoreVector128x4Double",                                                                                ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "StoreVector128x4",                                                                                                                                                               ["Op1BaseType"] = "double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "double",                                                   ["LargestVectorSize"] = "16",                                                                ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()",                                                                                       ["ValidateIterResult"] = "input1[i] != result[i] || input2[i] != result[OpElementCount + i] || input3[i] != result[(OpElementCount * 2) + i] || input4[i] != result[(OpElementCount * 3) + i]"}),
     ("VecBinOpTest.template",             new Dictionary<string, string> { ["TestName"] = "Subtract_Vector128_Double",                                                                             ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "Subtract",                                                             ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double",  ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "Double",                                                              ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()",        ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()",                                                                                       ["ValidateIterResult"] = "BitConverter.DoubleToInt64Bits(Helpers.Subtract(left[i], right[i])) != BitConverter.DoubleToInt64Bits(result[i])"}),
     ("SimpleBinOpTest.template",          new Dictionary<string, string> { ["TestName"] = "SubtractSaturateScalar_Vector64_Byte",                                                                  ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractSaturateScalar",                                               ["RetVectorType"] = "Vector64",  ["RetBaseType"] = "Byte",    ["Op1VectorType"] = "Vector64",  ["Op1BaseType"] = "Byte",   ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Byte",                                                                ["LargestVectorSize"] = "8",  ["NextValueOp1"] = "TestLibrary.Generator.GetByte()",          ["NextValueOp2"] = "TestLibrary.Generator.GetByte()",                                                                                         ["ValidateFirstResult"] = "Helpers.SubtractSaturate(left[0], right[0]) != result[0]",                                                                                                             ["ValidateRemainingResults"] = "result[i] != 0"}),
     ("SimpleBinOpTest.template",          new Dictionary<string, string> { ["TestName"] = "SubtractSaturateScalar_Vector64_Int16",                                                                 ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "SubtractSaturateScalar",                                               ["RetVectorType"] = "Vector64",  ["RetBaseType"] = "Int16",   ["Op1VectorType"] = "Vector64",  ["Op1BaseType"] = "Int16",  ["Op2VectorType"] = "Vector64",  ["Op2BaseType"] = "Int16",                                                               ["LargestVectorSize"] = "8",  ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()",         ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()",                                                                                        ["ValidateFirstResult"] = "Helpers.SubtractSaturate(left[0], right[0]) != result[0]",                                                                                                             ["ValidateRemainingResults"] = "result[i] != 0"}),
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx2Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx2Test.template
index 95a807e9796856..0151bea010822a 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx2Test.template
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx2Test.template
@@ -22,7 +22,7 @@ namespace JIT.HardwareIntrinsics.Arm
         [Fact]
         public static void {TestName}()
         {
-            var test = new StoreVector{Op2VectorType}x2Test__{Op1BaseType}();
+            var test = new {TestName}Test();
             if (test.IsSupported)
             {
                 // Validates basic functionality works, using Unsafe.Read
@@ -62,7 +62,7 @@ namespace JIT.HardwareIntrinsics.Arm
         }
     }
 
-    public sealed unsafe class StoreVector{Op2VectorType}x2Test__{Op1BaseType}
+    public sealed unsafe class {TestName}Test
     {
         private struct DataTable
         {
@@ -133,7 +133,7 @@ namespace JIT.HardwareIntrinsics.Arm
                 return testStruct;
             }
 
-            public void RunStructFldScenario(StoreVector{Op2VectorType}x2Test__{Op1BaseType} testClass)
+            public void RunStructFldScenario({TestName}Test testClass)
             {
                 {Isa}.{Method}(({Op1BaseType}*)testClass._dataTable.outArrayPtr, (_fld1, _fld2));
 
@@ -154,7 +154,7 @@ namespace JIT.HardwareIntrinsics.Arm
 
         private DataTable _dataTable;
 
-        public StoreVector{Op2VectorType}x2Test__{Op1BaseType}()
+        public {TestName}Test()
         {
             Succeeded = true;
             for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; }
@@ -299,7 +299,7 @@ namespace JIT.HardwareIntrinsics.Arm
 
             if (!succeeded)
             {
-                TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<Int32>({Op2VectorType}<{Op2BaseType}>): {Method} failed:");
+                TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<void>({Op2BaseType} *, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>): {Method} failed:");
                 TestLibrary.TestFramework.LogInformation($" input1: ({string.Join(", ", input1)})");
                 TestLibrary.TestFramework.LogInformation($" input2: ({string.Join(", ", input2)})");
                 TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx3Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx3Test.template
new file mode 100644
index 00000000000000..c00cbf0250ef85
--- /dev/null
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx3Test.template
@@ -0,0 +1,331 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/******************************************************************************
+ * This file is auto-generated from a template file by the GenerateTests.csx  *
+ * script in src\tests\JIT\HardwareIntrinsics\Arm\Shared. In order to make    *
+ * changes, please update the corresponding template and run according to the *
+ * directions listed in the file.                                             *
+ ******************************************************************************/
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using Xunit;
+
+namespace JIT.HardwareIntrinsics.Arm
+{
+    public static partial class Program
+    {
+        [Fact]
+        public static void {TestName}()
+        {
+            var test = new {TestName}Test();
+            if (test.IsSupported)
+            {
+                // Validates basic functionality works, using Unsafe.Read
+                test.RunBasicScenario_UnsafeRead();
+
+                if (AdvSimd.IsSupported)
+                {
+                    // Validates basic functionality works, using Load
+                    test.RunBasicScenario_Load();
+                }
+
+                // Validates calling via reflection works, using Unsafe.Read
+                test.RunReflectionScenario_UnsafeRead();
+
+                // Validates passing a local works, using Unsafe.Read
+                test.RunLclVarScenario_UnsafeRead();
+
+                // Validates passing an instance member of a class works
+                test.RunClassFldScenario();
+
+                // Validates passing the field of a local struct works
+                test.RunStructLclFldScenario();
+
+                // Validates passing an instance member of a struct works
+                test.RunStructFldScenario();
+            }
+            else
+            {
+                // Validates we throw on unsupported hardware
+                test.RunUnsupportedScenario();
+            }
+
+            if (!test.Succeeded)
+            {
+                throw new Exception("One or more scenarios did not complete as expected.");
+            }
+        }
+    }
+
+    public sealed unsafe class {TestName}Test
+    {
+        private struct DataTable
+        {
+            private byte[] inArray1;
+            private byte[] inArray2;
+            private byte[] inArray3;
+            private byte[] outArray;
+
+            private GCHandle inHandle1;
+            private GCHandle inHandle2;
+            private GCHandle inHandle3;
+            private GCHandle outHandle;
+
+            private ulong alignment;
+
+            public DataTable({Op2BaseType}[] inArray1, {Op2BaseType}[] inArray2, {Op2BaseType}[] inArray3, {Op1BaseType}[] outArray, int alignment)
+            {
+                int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{Op1BaseType}>();
+                if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 4) < sizeOfoutArray)
+                {
+                    throw new ArgumentException("Invalid value of alignment");
+                }
+
+                this.inArray1 = new byte[alignment * 2];
+                this.inArray2 = new byte[alignment * 2];
+                this.inArray3 = new byte[alignment * 2];
+                this.outArray = new byte[alignment * 4];
+
+                this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
+                this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
+                this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
+                this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
+
+                this.alignment = (ulong)alignment;
+
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
+            }
+
+            public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
+
+            public void Dispose()
+            {
+                inHandle1.Free();
+                inHandle2.Free();
+                inHandle3.Free();
+                outHandle.Free();
+            }
+
+            private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
+            {
+                return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
+            }
+        }
+
+        private struct TestStruct
+        {
+            public {Op2VectorType}<{Op2BaseType}> _fld1;
+            public {Op2VectorType}<{Op2BaseType}> _fld2;
+            public {Op2VectorType}<{Op2BaseType}> _fld3;
+
+            public static TestStruct Create()
+            {
+                var testStruct = new TestStruct();
+
+                for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; _data3[i] = {NextValueOp2}; }
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op2BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld3), ref Unsafe.As<{Op2BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+
+                return testStruct;
+            }
+
+            public void RunStructFldScenario({TestName}Test testClass)
+            {
+                {Isa}.{Method}(({Op1BaseType}*)testClass._dataTable.outArrayPtr, (_fld1, _fld2, _fld3));
+
+                testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
+            }
+        }
+
+        private static readonly int LargestVectorSize = {LargestVectorSize};
+
+        private static readonly int OpElementCount = Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>() / sizeof({Op2BaseType});
+        private static readonly int DestElementCount = OpElementCount * 3;
+
+        private static {Op2BaseType}[] _data1 = new {Op2BaseType}[OpElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[OpElementCount];
+        private static {Op2BaseType}[] _data3 = new {Op2BaseType}[OpElementCount];
+
+        private {Op2VectorType}<{Op2BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
+        private {Op2VectorType}<{Op2BaseType}> _fld3;
+
+        private DataTable _dataTable;
+
+        public {TestName}Test()
+        {
+            Succeeded = true;
+            for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; _data3[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op2BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld3), ref Unsafe.As<{Op2BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+
+            for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; _data3[i] = {NextValueOp2}; }
+            _dataTable = new DataTable(_data1, _data2, _data3, new {Op1BaseType}[DestElementCount], LargestVectorSize);
+        }
+
+        public bool IsSupported => {Isa}.IsSupported;
+
+        public bool Succeeded { get; set; }
+
+        public void RunBasicScenario_UnsafeRead()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
+
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray1Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray3Ptr)));
+
+            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
+        }
+
+        public void RunBasicScenario_Load()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, ({LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray1Ptr)), {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray3Ptr))));
+
+            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
+        }
+
+        public void RunReflectionScenario_UnsafeRead()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
+
+            typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1BaseType}*), typeof(({Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>))}).
+            Invoke(null, new object[] {
+                                 Pointer.Box(_dataTable.outArrayPtr, typeof({Op1BaseType}*)),
+                                 (Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray1Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray3Ptr)) });
+
+            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
+        }
+
+        public void RunLclVarScenario_UnsafeRead()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
+            var op1 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray1Ptr);
+            var op2 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var op3 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray3Ptr);
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (op1, op2, op3));
+
+            ValidateResult(op1, op2, op3, _dataTable.outArrayPtr);
+        }
+
+        public void RunClassFldScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (_fld1, _fld2, _fld3));
+
+            ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
+        }
+
+        public void RunStructLclFldScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
+
+            var test = TestStruct.Create();
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (test._fld1, test._fld2, test._fld3));
+
+            ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
+        }
+
+        public void RunStructFldScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
+
+            var test = TestStruct.Create();
+            test.RunStructFldScenario(this);
+        }
+
+        public void RunUnsupportedScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
+
+            bool succeeded = false;
+
+            try
+            {
+                RunBasicScenario_UnsafeRead();
+            }
+            catch (PlatformNotSupportedException)
+            {
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
+            }
+        }
+
+        private void ValidateResult(void* op1, void* op2, void* op3, void* result, [CallerMemberName] string method = "")
+        {
+            {Op2BaseType}[] inArray1 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray3 = new {Op2BaseType}[OpElementCount];
+            {Op1BaseType}[] outArray = new {Op1BaseType}[DestElementCount];
+
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>() * 3);
+
+            ValidateResult(inArray1, inArray2, inArray3, outArray, method);
+        }
+
+        private void ValidateResult({Op2VectorType}<{Op2BaseType}> op1, {Op2VectorType}<{Op2BaseType}> op2, {Op2VectorType}<{Op2BaseType}> op3, void* result, [CallerMemberName] string method = "")
+        {
+            {Op2BaseType}[] inArray1 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray3 = new {Op2BaseType}[OpElementCount];
+            {Op1BaseType}[] outArray = new {Op1BaseType}[DestElementCount];
+
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray1[0]), op1);
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), op2);
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray3[0]), op3);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>() * 3);
+
+            ValidateResult(inArray1, inArray2, inArray3, outArray, method);
+        }
+
+        private void ValidateResult({Op2BaseType}[] input1, {Op2BaseType}[] input2, {Op2BaseType}[] input3, {Op1BaseType}[] result, [CallerMemberName] string method = "")
+        {
+            bool succeeded = true;
+
+            for (int i = 0; i < OpElementCount; i++)
+            {
+                if ({ValidateIterResult})
+                {
+                    succeeded = false;
+                    break;
+                }
+            }
+
+            if (!succeeded)
+            {
+                TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<void>({Op2BaseType} *, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>): {Method} failed:");
+                TestLibrary.TestFramework.LogInformation($" input1: ({string.Join(", ", input1)})");
+                TestLibrary.TestFramework.LogInformation($" input2: ({string.Join(", ", input2)})");
+                TestLibrary.TestFramework.LogInformation($" input3: ({string.Join(", ", input3)})");
+                TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
+                TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx4Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx4Test.template
new file mode 100644
index 00000000000000..d0413736426900
--- /dev/null
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreVectorx4Test.template
@@ -0,0 +1,350 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/******************************************************************************
+ * This file is auto-generated from a template file by the GenerateTests.csx  *
+ * script in src\tests\JIT\HardwareIntrinsics\Arm\Shared. In order to make    *
+ * changes, please update the corresponding template and run according to the *
+ * directions listed in the file.                                             *
+ ******************************************************************************/
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
+using Xunit;
+
+namespace JIT.HardwareIntrinsics.Arm
+{
+    public static partial class Program
+    {
+        [Fact]
+        public static void {TestName}()
+        {
+            var test = new {TestName}Test();
+            if (test.IsSupported)
+            {
+                // Validates basic functionality works, using Unsafe.Read
+                test.RunBasicScenario_UnsafeRead();
+
+                if (AdvSimd.IsSupported)
+                {
+                    // Validates basic functionality works, using Load
+                    test.RunBasicScenario_Load();
+                }
+
+                // Validates calling via reflection works, using Unsafe.Read
+                test.RunReflectionScenario_UnsafeRead();
+
+                // Validates passing a local works, using Unsafe.Read
+                test.RunLclVarScenario_UnsafeRead();
+
+                // Validates passing an instance member of a class works
+                test.RunClassFldScenario();
+
+                // Validates passing the field of a local struct works
+                test.RunStructLclFldScenario();
+
+                // Validates passing an instance member of a struct works
+                test.RunStructFldScenario();
+            }
+            else
+            {
+                // Validates we throw on unsupported hardware
+                test.RunUnsupportedScenario();
+            }
+
+            if (!test.Succeeded)
+            {
+                throw new Exception("One or more scenarios did not complete as expected.");
+            }
+        }
+    }
+
+    public sealed unsafe class {TestName}Test
+    {
+        private struct DataTable
+        {
+            private byte[] inArray1;
+            private byte[] inArray2;
+            private byte[] inArray3;
+            private byte[] inArray4;
+            private byte[] outArray;
+
+            private GCHandle inHandle1;
+            private GCHandle inHandle2;
+            private GCHandle inHandle3;
+            private GCHandle inHandle4;
+            private GCHandle outHandle;
+
+            private ulong alignment;
+
+            public DataTable({Op2BaseType}[] inArray1, {Op2BaseType}[] inArray2, {Op2BaseType}[] inArray3, {Op2BaseType}[] inArray4, {Op1BaseType}[] outArray, int alignment)
+            {
+                int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfinArray4 = inArray4.Length * Unsafe.SizeOf<{Op2BaseType}>();
+                int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{Op1BaseType}>();
+                if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 5) < sizeOfoutArray)
+                {
+                    throw new ArgumentException("Invalid value of alignment");
+                }
+
+                this.inArray1 = new byte[alignment * 2];
+                this.inArray2 = new byte[alignment * 2];
+                this.inArray3 = new byte[alignment * 2];
+                this.inArray4 = new byte[alignment * 2];
+                this.outArray = new byte[alignment * 5];
+
+                this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
+                this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
+                this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
+                this.inHandle4 = GCHandle.Alloc(this.inArray4, GCHandleType.Pinned);
+                this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
+
+                this.alignment = (ulong)alignment;
+
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
+                Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray4Ptr), ref Unsafe.As<{Op2BaseType}, byte>(ref inArray4[0]), (uint)sizeOfinArray4);
+            }
+
+            public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* inArray4Ptr => Align((byte*)(inHandle4.AddrOfPinnedObject().ToPointer()), alignment);
+            public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
+
+            public void Dispose()
+            {
+                inHandle1.Free();
+                inHandle2.Free();
+                inHandle3.Free();
+                inHandle4.Free();
+                outHandle.Free();
+            }
+
+            private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
+            {
+                return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
+            }
+        }
+
+        private struct TestStruct
+        {
+            public {Op2VectorType}<{Op2BaseType}> _fld1;
+            public {Op2VectorType}<{Op2BaseType}> _fld2;
+            public {Op2VectorType}<{Op2BaseType}> _fld3;
+            public {Op2VectorType}<{Op2BaseType}> _fld4;
+
+            public static TestStruct Create()
+            {
+                var testStruct = new TestStruct();
+
+                for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; _data3[i] = {NextValueOp2}; _data4[i] = {NextValueOp2}; }
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op2BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld3), ref Unsafe.As<{Op2BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+                Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld4), ref Unsafe.As<{Op2BaseType}, byte>(ref _data4[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+
+                return testStruct;
+            }
+
+            public void RunStructFldScenario({TestName}Test testClass)
+            {
+                {Isa}.{Method}(({Op1BaseType}*)testClass._dataTable.outArrayPtr, (_fld1, _fld2, _fld3, _fld4));
+
+                testClass.ValidateResult(_fld1, _fld2, _fld3, _fld4, testClass._dataTable.outArrayPtr);
+            }
+        }
+
+        private static readonly int LargestVectorSize = {LargestVectorSize};
+
+        private static readonly int OpElementCount = Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>() / sizeof({Op2BaseType});
+        private static readonly int DestElementCount = OpElementCount * 4;
+
+        private static {Op2BaseType}[] _data1 = new {Op2BaseType}[OpElementCount];
+        private static {Op2BaseType}[] _data2 = new {Op2BaseType}[OpElementCount];
+        private static {Op2BaseType}[] _data3 = new {Op2BaseType}[OpElementCount];
+        private static {Op2BaseType}[] _data4 = new {Op2BaseType}[OpElementCount];
+
+        private {Op2VectorType}<{Op2BaseType}> _fld1;
+        private {Op2VectorType}<{Op2BaseType}> _fld2;
+        private {Op2VectorType}<{Op2BaseType}> _fld3;
+        private {Op2VectorType}<{Op2BaseType}> _fld4;
+
+        private DataTable _dataTable;
+
+        public {TestName}Test()
+        {
+            Succeeded = true;
+            for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; _data3[i] = {NextValueOp2}; _data4[i] = {NextValueOp2}; }
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op2BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld3), ref Unsafe.As<{Op2BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _fld4), ref Unsafe.As<{Op2BaseType}, byte>(ref _data4[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+
+            for (var i = 0; i < OpElementCount; i++) { _data1[i] = {NextValueOp2}; _data2[i] = {NextValueOp2}; _data3[i] = {NextValueOp2}; _data4[i] = {NextValueOp2}; }
+            _dataTable = new DataTable(_data1, _data2, _data3, _data4, new {Op1BaseType}[DestElementCount], LargestVectorSize);
+        }
+
+        public bool IsSupported => {Isa}.IsSupported;
+
+        public bool Succeeded { get; set; }
+
+        public void RunBasicScenario_UnsafeRead()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
+
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray1Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray3Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray4Ptr)));
+
+            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.outArrayPtr);
+        }
+
+        public void RunBasicScenario_Load()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, ({LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray1Ptr)), {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray3Ptr)), {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray4Ptr))));
+
+            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.outArrayPtr);
+        }
+
+        public void RunReflectionScenario_UnsafeRead()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead));
+
+            typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1BaseType}*), typeof(({Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>))}).
+            Invoke(null, new object[] {
+                                 Pointer.Box(_dataTable.outArrayPtr, typeof({Op1BaseType}*)),
+                                 (Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray1Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray3Ptr), Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray4Ptr)) });
+
+            ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.outArrayPtr);
+        }
+
+        public void RunLclVarScenario_UnsafeRead()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
+            var op1 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray1Ptr);
+            var op2 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray2Ptr);
+            var op3 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray3Ptr);
+            var op4 = Unsafe.Read<{Op2VectorType}<{Op2BaseType}>>(_dataTable.inArray4Ptr);
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (op1, op2, op3, op4));
+
+            ValidateResult(op1, op2, op3, op4, _dataTable.outArrayPtr);
+        }
+
+        public void RunClassFldScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (_fld1, _fld2, _fld3, _fld4));
+
+            ValidateResult(_fld1, _fld2, _fld3, _fld4, _dataTable.outArrayPtr);
+        }
+
+        public void RunStructLclFldScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
+
+            var test = TestStruct.Create();
+            {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, (test._fld1, test._fld2, test._fld3, test._fld4));
+
+            ValidateResult(test._fld1, test._fld2, test._fld3, test._fld4, _dataTable.outArrayPtr);
+        }
+
+        public void RunStructFldScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));
+
+            var test = TestStruct.Create();
+            test.RunStructFldScenario(this);
+        }
+
+        public void RunUnsupportedScenario()
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario));
+
+            bool succeeded = false;
+
+            try
+            {
+                RunBasicScenario_UnsafeRead();
+            }
+            catch (PlatformNotSupportedException)
+            {
+                succeeded = true;
+            }
+
+            if (!succeeded)
+            {
+                Succeeded = false;
+            }
+        }
+
+        private void ValidateResult(void* op1, void* op2, void* op3, void* op4, void* result, [CallerMemberName] string method = "")
+        {
+            {Op2BaseType}[] inArray1 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray3 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray4 = new {Op2BaseType}[OpElementCount];
+            {Op1BaseType}[] outArray = new {Op1BaseType}[DestElementCount];
+
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), ref Unsafe.AsRef<byte>(op2), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(op3), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray4[0]), ref Unsafe.AsRef<byte>(op4), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>() * 4);
+
+            ValidateResult(inArray1, inArray2, inArray3, inArray4, outArray, method);
+        }
+
+        private void ValidateResult({Op2VectorType}<{Op2BaseType}> op1, {Op2VectorType}<{Op2BaseType}> op2, {Op2VectorType}<{Op2BaseType}> op3, {Op2VectorType}<{Op2BaseType}> op4, void* result, [CallerMemberName] string method = "")
+        {
+            {Op2BaseType}[] inArray1 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray2 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray3 = new {Op2BaseType}[OpElementCount];
+            {Op2BaseType}[] inArray4 = new {Op2BaseType}[OpElementCount];
+            {Op1BaseType}[] outArray = new {Op1BaseType}[DestElementCount];
+
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray1[0]), op1);
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray2[0]), op2);
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray3[0]), op3);
+            Unsafe.WriteUnaligned(ref Unsafe.As<{Op2BaseType}, byte>(ref inArray4[0]), op4);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>() * 4);
+
+            ValidateResult(inArray1, inArray2, inArray3, inArray4, outArray, method);
+        }
+
+        private void ValidateResult({Op2BaseType}[] input1, {Op2BaseType}[] input2, {Op2BaseType}[] input3,  {Op2BaseType}[] input4, {Op1BaseType}[] result, [CallerMemberName] string method = "")
+        {
+            bool succeeded = true;
+
+            for (int i = 0; i < OpElementCount; i++)
+            {
+                if ({ValidateIterResult})
+                {
+                    succeeded = false;
+                    break;
+                }
+            }
+
+            if (!succeeded)
+            {
+                TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<void>({Op2BaseType} *, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>, {Op2VectorType}<{Op2BaseType}>): {Method} failed:");
+                TestLibrary.TestFramework.LogInformation($" input1: ({string.Join(", ", input1)})");
+                TestLibrary.TestFramework.LogInformation($" input2: ({string.Join(", ", input2)})");
+                TestLibrary.TestFramework.LogInformation($" input3: ({string.Join(", ", input3)})");
+                TestLibrary.TestFramework.LogInformation($" input4: ({string.Join(", ", input4)})");
+                TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})");
+                TestLibrary.TestFramework.LogInformation(string.Empty);
+
+                Succeeded = false;
+            }
+        }
+    }
+}
\ No newline at end of file