From 15b35dd81070352cdb4cabc47afe43eaf39a187c Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 17 Jun 2024 09:08:38 -0700
Subject: [PATCH 1/4] Ensure folding MultiplyByScalar broadcasts up to the
 right length

---
 src/coreclr/jit/gentree.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp
index 9a899443294b5..335eb6e60d8ef 100644
--- a/src/coreclr/jit/gentree.cpp
+++ b/src/coreclr/jit/gentree.cpp
@@ -29916,7 +29916,9 @@ GenTree* Compiler::gtFoldExprHWIntrinsic(GenTreeHWIntrinsic* tree)
 
                     // MultiplyByScalar takes a vector as the second operand but only utilizes element 0
                     // We need to extract it and then functionally broadcast it up for the evaluation to
-                    // work as expected.
+                    // work as expected. Ensuring we broadcast up to the target vector size.
+
+                    otherNode->gtType = retType;
 
                     if (varTypeIsFloating(simdBaseType))
                     {

From b8624b3a60e6a1f4a92dae83898664030d9727d9 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 17 Jun 2024 09:53:54 -0700
Subject: [PATCH 2/4] Fix the ConstantExpected attributes for AdvSimd shift
 APIs

---
 .../Arm/AdvSimd.PlatformNotSupported.cs       | 539 +++++++++---------
 .../System/Runtime/Intrinsics/Arm/AdvSimd.cs  | 508 ++++++++---------
 2 files changed, 523 insertions(+), 524 deletions(-)

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 e358c5663db26..d59bc76620e4c 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
@@ -21,7 +21,6 @@ internal AdvSimd() { }
 
         public static new bool IsSupported { [Intrinsic] get { return false; } }
 
-        // [Intrinsic]
         // public new abstract class Arm32 : ArmBase.Arm32
         // {
         //     internal Arm32() { }
@@ -672,6 +671,7 @@ internal Arm64() { }
             ///   A64: USQADD Dd, Dn
             /// </summary>
             public static Vector64<ulong> AddSaturateScalar(Vector64<ulong> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
             /// <summary>
             /// float64x2_t vrndpq_f64 (float64x2_t a)
             ///   A64: FRINTP Vd.2D, Vn.2D
@@ -3262,55 +3262,55 @@ internal Arm64() { }
             /// uint8_t vqshlb_n_u8 (uint8_t a, const int n)
             ///   A64: UQSHL Bd, Bn, #n
             /// </summary>
-            public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqshlh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHL Hd, Hn, #n
             /// </summary>
-            public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqshls_n_s32 (int32_t a, const int n)
             ///   A64: SQSHL Sd, Sn, #n
             /// </summary>
-            public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8_t vqshlb_n_s8 (int8_t a, const int n)
             ///   A64: SQSHL Bd, Bn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshlh_n_u16 (uint16_t a, const int n)
             ///   A64: UQSHL Hd, Hn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32_t vqshls_n_u32 (uint32_t a, const int n)
             ///   A64: UQSHL Sd, Sn, #n
             /// </summary>
-            public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshluh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHLU Hd, Hn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32_t vqshlus_n_s32 (int32_t a, const int n)
             ///   A64: SQSHLU Sd, Sn, #n
             /// </summary>
-            public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqshlub_n_s8 (int8_t a, const int n)
             ///   A64: SQSHLU Bd, Bn, #n
             /// </summary>
-            public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b)
@@ -3394,19 +3394,19 @@ internal Arm64() { }
             /// int32_t vqshrnd_n_s64 (int64_t a, const int n)
             ///   A64: SQSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8_t vqshrnh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqshrunh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHRUN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshruns_n_s32 (int32_t a, const int n)
@@ -3418,7 +3418,7 @@ internal Arm64() { }
             /// uint32_t vqshrund_n_s64 (int64_t a, const int n)
             ///   A64: SQSHRUN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrshrns_n_s32 (int32_t a, const int n)
@@ -3430,19 +3430,19 @@ internal Arm64() { }
             /// int32_t vqrshrnd_n_s64 (int64_t a, const int n)
             ///   A64: SQRSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8_t vqrshrnh_n_s16 (int16_t a, const int n)
             ///   A64: SQRSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n)
             ///   A64: SQRSHRUN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqrshruns_n_s32 (int32_t a, const int n)
@@ -3454,13 +3454,13 @@ internal Arm64() { }
             /// uint32_t vqrshrund_n_s64 (int64_t a, const int n)
             ///   A64: SQRSHRUN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
@@ -3472,13 +3472,13 @@ internal Arm64() { }
             /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
@@ -3490,13 +3490,13 @@ internal Arm64() { }
             /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQRSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
@@ -3510,14 +3510,14 @@ internal Arm64() { }
             ///   A64: UQRSHRN Sd, Dn, #n
             /// </summary>
             [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQRSHRN Bd, Hn, #n
             /// </summary>
             [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
@@ -3529,7 +3529,7 @@ internal Arm64() { }
             /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQRSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vsqrt_f32 (float32x2_t a)
@@ -3946,7 +3946,7 @@ internal Arm64() { }
             public static unsafe void StoreSelectedScalar(float* address, (Vector128<float> value1, Vector128<float> value2, Vector128<float> value3, Vector128<float> value4) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///   A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn]
+            ///   A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn]
             /// </summary>
             public static unsafe void StoreSelectedScalar(double* address, (Vector128<double> value1, Vector128<double> value2, Vector128<double> value3, Vector128<double> value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
@@ -3981,7 +3981,7 @@ internal Arm64() { }
             public static unsafe void StoreVector128x2AndZip(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///    A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
+            ///   A64: ST2 { Vn.2D, Vn+1.2D }, [Xn]
             /// </summary>
             public static unsafe void StoreVector128x2AndZip(long* address, (Vector128<long> Value1, Vector128<long> Value2) value) { throw new PlatformNotSupportedException(); }
 
@@ -4131,7 +4131,7 @@ internal Arm64() { }
             public static unsafe void StoreVector128x2(uint* address, (Vector128<uint> Value1, Vector128<uint> Value2) value) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            ///    A64: ST1 { 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(); }
 
@@ -4509,14 +4509,14 @@ internal Arm64() { }
             public static Vector128<ushort> TransposeOdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            /// uint32x4_t vtrn1q_u32(uint32x4_t a, uint32x4_t b)
-            ///   A64: TRN1 Vd.4S, Vn.4S, Vm.4S
+            /// uint32x4_t vtrn2q_u32(uint32x4_t a, uint32x4_t b)
+            ///   A64: TRN2 Vd.4S, Vn.4S, Vm.4S
             /// </summary>
             public static Vector128<uint> TransposeOdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            /// uint64x2_t vtrn1q_u64(uint64x2_t a, uint64x2_t b)
-            ///   A64: TRN1 Vd.2D, Vn.2D, Vm.2D
+            /// uint64x2_t vtrn2q_u64(uint64x2_t a, uint64x2_t b)
+            ///   A64: TRN2 Vd.2D, Vn.2D, Vm.2D
             /// </summary>
             public static Vector128<ulong> TransposeOdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
 
@@ -4701,7 +4701,7 @@ internal Arm64() { }
             public static Vector128<sbyte> UnzipOdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
-            /// float32x4_t vuzp2_f32(float32x4_t a, float32x4_t b)
+            /// float32x4_t vuzp2q_f32(float32x4_t a, float32x4_t b)
             ///   A64: UZP2 Vd.4S, Vn.4S, Vm.4S
             /// </summary>
             public static Vector128<float> UnzipOdd(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
@@ -4788,7 +4788,6 @@ internal Arm64() { }
             ///  uint8x16_t vqtbx2q_u8(uint8x16x2_t t, uint8x16_t idx)
             ///   A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B
             /// </summary>
-
             public static Vector128<byte> VectorTableLookupExtension(Vector128<byte> defaultValues, (Vector128<byte>, Vector128<byte>) table, Vector128<byte> byteIndexes) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
@@ -9712,7 +9711,7 @@ internal Arm64() { }
         public static unsafe (Vector64<uint> Value1, Vector64<uint> Value2, Vector64<uint> Value3, Vector64<uint> Value4) LoadVector64x4AndUnzip(uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, 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) { throw new PlatformNotSupportedException(); }
 
@@ -13415,56 +13414,56 @@ internal Arm64() { }
         ///   A32: VSLI.8 Dd, Dm, #n
         ///   A64: SLI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Dd, Dm, #n
         ///   A64: SLI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Dd, Dm, #n
         ///   A64: SLI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n))
         ///   A32: VSLI.8 Dd, Dm, #n
         ///   A64: SLI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Dd, Dm, #n
         ///   A64: SLI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Dd, Dm, #n
         ///   A64: SLI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n))
         ///   A32: VSLI.8 Qd, Qm, #n
         ///   A64: SLI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Qd, Qm, #n
         ///   A64: SLI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
@@ -13478,21 +13477,21 @@ internal Arm64() { }
         ///   A32: VSLI.64 Qd, Qm, #n
         ///   A64: SLI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n))
         ///   A32: VSLI.8 Qd, Qm, #n
         ///   A64: SLI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Qd, Qm, #n
         ///   A64: SLI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
@@ -13506,98 +13505,98 @@ internal Arm64() { }
         ///   A32: VSLI.64 Qd, Qm, #n
         ///   A64: SLI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n))
         ///   A32: VSLI.64 Dd, Dm, #n
         ///   A64: SLI Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n))
         ///   A32: VSLI.64 Dd, Dm, #n
         ///   A64: SLI Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHL.I8 Dd, Dm, #n
         ///   A64: SHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vshl_n_s16 (int16x4_t a, const int n)
         ///   A32: VSHL.I16 Dd, Dm, #n
         ///   A64: SHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftLeftLogical(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftLeftLogical(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vshl_n_s32 (int32x2_t a, const int n)
         ///   A32: VSHL.I32 Dd, Dm, #n
         ///   A64: SHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftLeftLogical(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftLeftLogical(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vshl_n_s8 (int8x8_t a, const int n)
         ///   A32: VSHL.I8 Dd, Dm, #n
         ///   A64: SHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHL.I16 Dd, Dm, #n
         ///   A64: SHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHL.I32 Dd, Dm, #n
         ///   A64: SHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHL.I8 Qd, Qm, #n
         ///   A64: SHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHL.I16 Qd, Qm, #n
         ///   A64: SHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n)
         ///   A32: VSHL.I64 Qd, Qm, #n
         ///   A64: SHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n)
         ///   A32: VSHL.I8 Qd, Qm, #n
         ///   A64: SHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHL.I16 Qd, Qm, #n
         ///   A64: SHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n)
@@ -13611,63 +13610,63 @@ internal Arm64() { }
         ///   A32: VSHL.I64 Qd, Qm, #n
         ///   A64: SHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n)
         ///   A32: VQSHL.U8 Dd, Dm, #n
         ///   A64: UQSHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n)
         ///   A32: VQSHL.S16 Dd, Dm, #n
         ///   A64: SQSHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n)
         ///   A32: VQSHL.S32 Dd, Dm, #n
         ///   A64: SQSHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n)
         ///   A32: VQSHL.S8 Dd, Dm, #n
         ///   A64: SQSHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n)
         ///   A32: VQSHL.U16 Dd, Dm, #n
         ///   A64: UQSHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n)
         ///   A32: VQSHL.U32 Dd, Dm, #n
         ///   A64: UQSHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VQSHL.U8 Qd, Qm, #n
         ///   A64: UQSHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHL.S16 Qd, Qm, #n
         ///   A64: SQSHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n)
@@ -13681,21 +13680,21 @@ internal Arm64() { }
         ///   A32: VQSHL.S64 Qd, Qm, #n
         ///   A64: SQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n)
         ///   A32: VQSHL.S8 Qd, Qm, #n
         ///   A64: SQSHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQSHL.U16 Qd, Qm, #n
         ///   A64: UQSHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n)
@@ -13709,49 +13708,49 @@ internal Arm64() { }
         ///   A32: VQSHL.U64 Qd, Qm, #n
         ///   A64: UQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n)
         ///   A32: VQSHL.S64 Dd, Dm, #n
         ///   A64: SQSHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n)
         ///   A32: VQSHL.U64 Dd, Dm, #n
         ///   A64: UQSHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n)
         ///   A32: VQSHLU.S16 Dd, Dm, #n
         ///   A64: SQSHLU Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n)
         ///   A32: VQSHLU.S32 Dd, Dm, #n
         ///   A64: SQSHLU Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n)
         ///   A32: VQSHLU.S8 Dd, Dm, #n
         ///   A64: SQSHLU Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHLU.S16 Qd, Qm, #n
         ///   A64: SQSHLU Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n)
@@ -13765,91 +13764,91 @@ internal Arm64() { }
         ///   A32: VQSHLU.S64 Qd, Qm, #n
         ///   A64: SQSHLU Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n)
         ///   A32: VQSHLU.S8 Qd, Qm, #n
         ///   A64: SQSHLU Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n)
         ///   A32: VQSHLU.S64 Dd, Dm, #n
         ///   A64: SQSHLU Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x1_t vshl_n_s64 (int64x1_t a, const int n)
         ///   A32: VSHL.I64 Dd, Dm, #n
         ///   A64: SHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n)
         ///   A32: VSHL.I64 Dd, Dm, #n
         ///   A64: SHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHLL.U8 Qd, Dm, #n
         ///   A64: USHLL Vd.8H, Vn.8B, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vshll_n_s16 (int16x4_t a, const int n)
         ///   A32: VSHLL.S16 Qd, Dm, #n
         ///   A64: SSHLL Vd.4S, Vn.4H, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vshll_n_s32 (int32x2_t a, const int n)
         ///   A32: VSHLL.S32 Qd, Dm, #n
         ///   A64: SSHLL Vd.2D, Vn.2S, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vshll_n_s8 (int8x8_t a, const int n)
         ///   A32: VSHLL.S8 Qd, Dm, #n
         ///   A64: SSHLL Vd.8H, Vn.8B, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHLL.U16 Qd, Dm, #n
         ///   A64: USHLL Vd.4S, Vn.4H, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHLL.U32 Qd, Dm, #n
         ///   A64: USHLL Vd.2D, Vn.2S, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHLL.U8 Qd, Dm+1, #n
         ///   A64: USHLL2 Vd.8H, Vn.16B, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHLL.S16 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.4S, Vn.8H, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n)
@@ -13863,14 +13862,14 @@ internal Arm64() { }
         ///   A32: VSHLL.S8 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.8H, Vn.16B, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHLL.U16 Qd, Dm+1, #n
         ///   A64: USHLL2 Vd.4S, Vn.8H, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n)
@@ -14332,56 +14331,56 @@ internal Arm64() { }
         ///   A32: VSRI.8 Dd, Dm, #n
         ///   A64: SRI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Dd, Dm, #n
         ///   A64: SRI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Dd, Dm, #n
         ///   A64: SRI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n))
         ///   A32: VSRI.8 Dd, Dm, #n
         ///   A64: SRI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Dd, Dm, #n
         ///   A64: SRI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Dd, Dm, #n
         ///   A64: SRI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n))
         ///   A32: VSRI.8 Qd, Qm, #n
         ///   A64: SRI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Qd, Qm, #n
         ///   A64: SRI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
@@ -14395,21 +14394,21 @@ internal Arm64() { }
         ///   A32: VSRI.64 Qd, Qm, #n
         ///   A64: SRI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n))
         ///   A32: VSRI.8 Qd, Qm, #n
         ///   A64: SRI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Qd, Qm, #n
         ///   A64: SRI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
@@ -14423,49 +14422,49 @@ internal Arm64() { }
         ///   A32: VSRI.64 Qd, Qm, #n
         ///   A64: SRI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n))
         ///   A32: VSRI.64 Dd, Dm, #n
         ///   A64: SRI Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///  uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n))
-        ///    A32: VSRI.64 Dd, Dm, #n
-        ///    A64: SRI Dd, Dn, #n
+        /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n))
+        ///   A32: VSRI.64 Dd, Dm, #n
+        ///   A64: SRI Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vshr_n_s16 (int16x4_t a, const int n)
         ///   A32: VSHR.S16 Dd, Dm, #n
         ///   A64: SSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vshr_n_s32 (int32x2_t a, const int n)
         ///   A32: VSHR.S32 Dd, Dm, #n
         ///   A64: SSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vshr_n_s8 (int8x8_t a, const int n)
         ///   A32: VSHR.S8 Dd, Dm, #n
         ///   A64: SSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHR.S16 Qd, Qm, #n
         ///   A64: SSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n)
@@ -14479,42 +14478,42 @@ internal Arm64() { }
         ///   A32: VSHR.S64 Qd, Qm, #n
         ///   A64: SSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n)
         ///   A32: VSHR.S8 Qd, Qm, #n
         ///   A64: SSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n)
         ///   A32: VSRA.S16 Dd, Dm, #n
         ///   A64: SSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n)
         ///   A32: VSRA.S32 Dd, Dm, #n
         ///   A64: SSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n)
         ///   A32: VSRA.S8 Dd, Dm, #n
         ///   A64: SSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n)
         ///   A32: VSRA.S16 Qd, Qm, #n
         ///   A64: SSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
@@ -14528,133 +14527,133 @@ internal Arm64() { }
         ///   A32: VSRA.S64 Qd, Qm, #n
         ///   A64: SSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n)
         ///   A32: VSRA.S8 Qd, Qm, #n
         ///   A64: SSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n)
         ///   A32: VSRA.S64 Dd, Dm, #n
         ///   A64: SSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHRN.S32 Dd, Qm, #n
         ///   A64: SQSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHRN.S64 Dd, Qm, #n
         ///   A64: SQSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHRN.S16 Dd, Qm, #n
         ///   A64: SQSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHRUN.S16 Dd, Qm, #n
         ///   A64: SQSHRUN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHRUN.S32 Dd, Qm, #n
         ///   A64: SQSHRUN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHRUN.S64 Dd, Qm, #n
         ///   A64: SQSHRUN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n)
         ///   A32: VQSHRUN.S16 Dd+1, Dn, #n
         ///   A64: SQSHRUN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n)
         ///   A32: VQSHRUN.S32 Dd+1, Dn, #n
         ///   A64: SQSHRUN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n)
         ///   A32: VQSHRUN.S64 Dd+1, Dn, #n
         ///   A64: SQSHRUN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VQSHRN.S32 Dd+1, Qm, #n
         ///   A64: SQSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VQSHRN.S64 Dd+1, Qm, #n
         ///   A64: SQSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VQSHRN.S16 Dd+1, Qm, #n
         ///   A64: SQSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n)
         ///   A32: VRSHR.S16 Dd, Dm, #n
         ///   A64: SRSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n)
         ///   A32: VRSHR.S32 Dd, Dm, #n
         ///   A64: SRSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n)
         ///   A32: VRSHR.S8 Dd, Dm, #n
         ///   A64: SRSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n)
         ///   A32: VRSHR.S16 Qd, Qm, #n
         ///   A64: SRSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n)
@@ -14668,42 +14667,42 @@ internal Arm64() { }
         ///   A32: VRSHR.S64 Qd, Qm, #n
         ///   A64: SRSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n)
         ///   A32: VRSHR.S8 Qd, Qm, #n
         ///   A64: SRSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n)
         ///   A32: VRSRA.S16 Dd, Dm, #n
         ///   A64: SRSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n)
         ///   A32: VRSRA.S32 Dd, Dm, #n
         ///   A64: SRSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n)
         ///   A32: VRSRA.S8 Dd, Dm, #n
         ///   A64: SRSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n)
         ///   A32: VRSRA.S16 Qd, Qm, #n
         ///   A64: SRSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
@@ -14717,175 +14716,175 @@ internal Arm64() { }
         ///   A32: VRSRA.S64 Qd, Qm, #n
         ///   A64: SRSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n)
         ///   A32: VRSRA.S8 Qd, Qm, #n
         ///   A64: SRSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n)
         ///   A32: VRSRA.S64 Dd, Dm, #n
         ///   A64: SRSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VQRSHRN.S32 Dd, Qm, #n
         ///   A64: SQRSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VQRSHRN.S64 Dd, Qm, #n
         ///   A64: SQRSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VQRSHRN.S16 Dd, Qm, #n
         ///   A64: SQRSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n)
         ///   A32: VQRSHRUN.S16 Dd, Qm, #n
         ///   A64: SQRSHRUN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n)
         ///   A32: VQRSHRUN.S32 Dd, Qm, #n
         ///   A64: SQRSHRUN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n)
         ///   A32: VQRSHRUN.S64 Dd, Qm, #n
         ///   A64: SQRSHRUN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n)
         ///   A32: VQRSHRUN.S16 Dd+1, Dn, #n
         ///   A64: SQRSHRUN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n)
         ///   A32: VQRSHRUN.S32 Dd+1, Dn, #n
         ///   A64: SQRSHRUN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n)
         ///   A32: VQRSHRUN.S64 Dd+1, Dn, #n
         ///   A64: SQRSHRUN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VQRSHRN.S32 Dd+1, Dn, #n
         ///   A64: SQRSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VQRSHRN.S64 Dd+1, Dn, #n
         ///   A64: SQRSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VQRSHRN.S16 Dd+1, Dn, #n
         ///   A64: SQRSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n)
         ///   A32: VRSHR.S64 Dd, Dm, #n
         ///   A64: SRSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x1_t vshr_n_s64 (int64x1_t a, const int n)
         ///   A32: VSHR.S64 Dd, Dm, #n
         ///   A64: SSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHR.U8 Dd, Dm, #n
         ///   A64: USHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHR.U16 Dd, Dm, #n
         ///   A64: USHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogical(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogical(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHR.U32 Dd, Dm, #n
         ///   A64: USHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogical(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogical(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHR.U8 Dd, Dm, #n
         ///   A64: USHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHR.U16 Dd, Dm, #n
         ///   A64: USHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHR.U32 Dd, Dm, #n
         ///   A64: USHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHR.U8 Qd, Qm, #n
         ///   A64: USHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHR.U16 Qd, Qm, #n
         ///   A64: USHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
@@ -14899,21 +14898,21 @@ internal Arm64() { }
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHR.U8 Qd, Qm, #n
         ///   A64: USHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHR.U16 Qd, Qm, #n
         ///   A64: USHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
@@ -14927,63 +14926,63 @@ internal Arm64() { }
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VSRA.U8 Dd, Dm, #n
         ///   A64: USRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VSRA.U16 Dd, Dm, #n
         ///   A64: USRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VSRA.U32 Dd, Dm, #n
         ///   A64: USRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VSRA.U8 Dd, Dm, #n
         ///   A64: USRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VSRA.U16 Dd, Dm, #n
         ///   A64: USRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VSRA.U32 Dd, Dm, #n
         ///   A64: USRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VSRA.U8 Qd, Qm, #n
         ///   A64: USRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VSRA.U16 Qd, Qm, #n
         ///   A64: USRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -14997,21 +14996,21 @@ internal Arm64() { }
         ///   A32: VSRA.U64 Qd, Qm, #n
         ///   A64: USRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VSRA.U8 Qd, Qm, #n
         ///   A64: USRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VSRA.U16 Qd, Qm, #n
         ///   A64: USRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -15025,245 +15024,245 @@ internal Arm64() { }
         ///   A32: VSRA.U64 Qd, Qm, #n
         ///   A64: USRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VSRA.U64 Dd, Dm, #n
         ///   A64: USRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VSRA.U64 Dd, Dm, #n
         ///   A64: USRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd, Qm, #n
         ///   A64: SHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd, Qm, #n
         ///   A64: SHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd, Qm, #n
         ///   A64: SHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd, Qm, #n
         ///   A64: SHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd, Qm, #n
         ///   A64: SHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd, Qm, #n
         ///   A64: SHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd, Qm, #n
         ///   A64: UQSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd, Qm, #n
         ///   A64: UQSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd, Qm, #n
         ///   A64: UQSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd, Qm, #n
         ///   A64: UQSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd, Qm, #n
         ///   A64: UQSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd, Qm, #n
         ///   A64: UQSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VRSHR.U8 Dd, Dm, #n
         ///   A64: URSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VRSHR.U16 Dd, Dm, #n
         ///   A64: URSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VRSHR.U32 Dd, Dm, #n
         ///   A64: URSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VRSHR.U8 Dd, Dm, #n
         ///   A64: URSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VRSHR.U16 Dd, Dm, #n
         ///   A64: URSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VRSHR.U32 Dd, Dm, #n
         ///   A64: URSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VRSHR.U8 Qd, Qm, #n
         ///   A64: URSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VRSHR.U16 Qd, Qm, #n
         ///   A64: URSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
@@ -15277,21 +15276,21 @@ internal Arm64() { }
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VRSHR.U8 Qd, Qm, #n
         ///   A64: URSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VRSHR.U16 Qd, Qm, #n
         ///   A64: URSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
@@ -15305,63 +15304,63 @@ internal Arm64() { }
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VRSRA.U8 Dd, Dm, #n
         ///   A64: URSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VRSRA.U16 Dd, Dm, #n
         ///   A64: URSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VRSRA.U32 Dd, Dm, #n
         ///   A64: URSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VRSRA.U8 Dd, Dm, #n
         ///   A64: URSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VRSRA.U16 Dd, Dm, #n
         ///   A64: URSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VRSRA.U32 Dd, Dm, #n
         ///   A64: URSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VRSRA.U8 Qd, Qm, #n
         ///   A64: URSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VRSRA.U16 Qd, Qm, #n
         ///   A64: URSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -15375,21 +15374,21 @@ internal Arm64() { }
         ///   A32: VRSRA.U64 Qd, Qm, #n
         ///   A64: URSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VRSRA.U8 Qd, Qm, #n
         ///   A64: URSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VRSRA.U16 Qd, Qm, #n
         ///   A64: URSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -15403,70 +15402,70 @@ internal Arm64() { }
         ///   A32: VRSRA.U64 Qd, Qm, #n
         ///   A64: URSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VRSRA.U64 Dd, Dm, #n
         ///   A64: URSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VRSRA.U64 Dd, Dm, #n
         ///   A64: URSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd, Qm, #n
         ///   A64: RSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd, Qm, #n
         ///   A64: RSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd, Qm, #n
         ///   A64: RSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd, Qm, #n
         ///   A64: RSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd, Qm, #n
         ///   A64: RSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd, Qm, #n
         ///   A64: RSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQRSHRN.U16 Dd, Qm, #n
         ///   A64: UQRSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n)
@@ -15474,7 +15473,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN Vd.4H, Vn.4S, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n)
@@ -15482,7 +15481,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN Vd.2S, Vn.2D, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n)
@@ -15490,28 +15489,28 @@ internal Arm64() { }
         ///   A64: UQRSHRN Vd.8B, Vn.8H, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQRSHRN.U32 Dd, Qm, #n
         ///   A64: UQRSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQRSHRN.U64 Dd, Qm, #n
         ///   A64: UQRSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VQRSHRN.U16 Dd+1, Dn, #n
         ///   A64: UQRSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
@@ -15519,7 +15518,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
@@ -15527,7 +15526,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
@@ -15535,91 +15534,91 @@ internal Arm64() { }
         ///   A64: UQRSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VQRSHRN.U32 Dd+1, Dn, #n
         ///   A64: UQRSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VQRSHRN.U64 Dd+1, Dn, #n
         ///   A64: UQRSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VRSHR.U64 Dd, Dm, #n
         ///   A64: URSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VRSHR.U64 Dd, Dm, #n
         ///   A64: URSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VSHR.U64 Dd, Dm, #n
         ///   A64: USHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VSHR.U64 Dd, Dm, #n
         ///   A64: USHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmovl_s16 (int16x4_t a)
@@ -15990,7 +15989,7 @@ internal Arm64() { }
         /// <summary>
         ///   A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ushort* address, (Vector64<ushort> value1, Vector64<ushort> value2, Vector64<ushort> value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(ushort* address, (Vector64<ushort> value1, Vector64<ushort> value2,  Vector64<ushort> value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         ///   A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn]
@@ -16003,7 +16002,7 @@ internal Arm64() { }
         public static unsafe void StoreSelectedScalar(uint* address, (Vector64<uint> value1, Vector64<uint> value2, Vector64<uint> value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
-        ///   A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn]
+        ///   A64: ST2 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn]
         /// </summary>
         public static unsafe void StoreSelectedScalar(float* address, (Vector64<float> value1, Vector64<float> value2, Vector64<float> value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
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 d4354ca639a43..1f5c1177f26b9 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
@@ -3260,55 +3260,55 @@ internal Arm64() { }
             /// uint8_t vqshlb_n_u8 (uint8_t a, const int n)
             ///   A64: UQSHL Bd, Bn, #n
             /// </summary>
-            public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
             /// <summary>
             /// int16_t vqshlh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHL Hd, Hn, #n
             /// </summary>
-            public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
             /// <summary>
             /// int32_t vqshls_n_s32 (int32_t a, const int n)
             ///   A64: SQSHL Sd, Sn, #n
             /// </summary>
-            public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
             /// <summary>
             /// int8_t vqshlb_n_s8 (int8_t a, const int n)
             ///   A64: SQSHL Bd, Bn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshlh_n_u16 (uint16_t a, const int n)
             ///   A64: UQSHL Hd, Hn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
             /// <summary>
             /// uint32_t vqshls_n_u32 (uint32_t a, const int n)
             ///   A64: UQSHL Sd, Sn, #n
             /// </summary>
-            public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshluh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHLU Hd, Hn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+            public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint32_t vqshlus_n_s32 (int32_t a, const int n)
             ///   A64: SQSHLU Sd, Sn, #n
             /// </summary>
-            public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+            public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint8_t vqshlub_n_s8 (int8_t a, const int n)
             ///   A64: SQSHLU Bd, Bn, #n
             /// </summary>
-            public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+            public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b)
@@ -3392,19 +3392,19 @@ internal Arm64() { }
             /// int32_t vqshrnd_n_s64 (int64_t a, const int n)
             ///   A64: SQSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// int8_t vqshrnh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint8_t vqshrunh_n_s16 (int16_t a, const int n)
             ///   A64: SQSHRUN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshruns_n_s32 (int32_t a, const int n)
@@ -3416,7 +3416,7 @@ internal Arm64() { }
             /// uint32_t vqshrund_n_s64 (int64_t a, const int n)
             ///   A64: SQSHRUN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// int16_t vqrshrns_n_s32 (int32_t a, const int n)
@@ -3428,19 +3428,19 @@ internal Arm64() { }
             /// int32_t vqrshrnd_n_s64 (int64_t a, const int n)
             ///   A64: SQRSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// int8_t vqrshrnh_n_s16 (int16_t a, const int n)
             ///   A64: SQRSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n)
             ///   A64: SQRSHRUN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint16_t vqrshruns_n_s32 (int32_t a, const int n)
@@ -3452,13 +3452,13 @@ internal Arm64() { }
             /// uint32_t vqrshrund_n_s64 (int64_t a, const int n)
             ///   A64: SQRSHRUN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
@@ -3470,13 +3470,13 @@ internal Arm64() { }
             /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
@@ -3488,13 +3488,13 @@ internal Arm64() { }
             /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQRSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
@@ -3508,14 +3508,14 @@ internal Arm64() { }
             ///   A64: UQRSHRN Sd, Dn, #n
             /// </summary>
             [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQRSHRN Bd, Hn, #n
             /// </summary>
             [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
@@ -3527,7 +3527,7 @@ internal Arm64() { }
             /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQRSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// float32x2_t vsqrt_f32 (float32x2_t a)
@@ -13412,56 +13412,56 @@ internal Arm64() { }
         ///   A32: VSLI.8 Dd, Dm, #n
         ///   A64: SLI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Dd, Dm, #n
         ///   A64: SLI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Dd, Dm, #n
         ///   A64: SLI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n))
         ///   A32: VSLI.8 Dd, Dm, #n
         ///   A64: SLI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Dd, Dm, #n
         ///   A64: SLI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Dd, Dm, #n
         ///   A64: SLI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n))
         ///   A32: VSLI.8 Qd, Qm, #n
         ///   A64: SLI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Qd, Qm, #n
         ///   A64: SLI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
@@ -13475,21 +13475,21 @@ internal Arm64() { }
         ///   A32: VSLI.64 Qd, Qm, #n
         ///   A64: SLI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n))
         ///   A32: VSLI.8 Qd, Qm, #n
         ///   A64: SLI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n))
         ///   A32: VSLI.16 Qd, Qm, #n
         ///   A64: SLI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
@@ -13503,98 +13503,98 @@ internal Arm64() { }
         ///   A32: VSLI.64 Qd, Qm, #n
         ///   A64: SLI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n))
         ///   A32: VSLI.64 Dd, Dm, #n
         ///   A64: SLI Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
+        public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
 
         /// <summary>
         /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n))
         ///   A32: VSLI.64 Dd, Dm, #n
         ///   A64: SLI Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
+        public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
 
         /// <summary>
         /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHL.I8 Dd, Dm, #n
         ///   A64: SHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// int16x4_t vshl_n_s16 (int16x4_t a, const int n)
         ///   A32: VSHL.I16 Dd, Dm, #n
         ///   A64: SHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftLeftLogical(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<short> ShiftLeftLogical(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// int32x2_t vshl_n_s32 (int32x2_t a, const int n)
         ///   A32: VSHL.I32 Dd, Dm, #n
         ///   A64: SHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftLeftLogical(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<int> ShiftLeftLogical(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// int8x8_t vshl_n_s8 (int8x8_t a, const int n)
         ///   A32: VSHL.I8 Dd, Dm, #n
         ///   A64: SHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHL.I16 Dd, Dm, #n
         ///   A64: SHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHL.I32 Dd, Dm, #n
         ///   A64: SHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHL.I8 Qd, Qm, #n
         ///   A64: SHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHL.I16 Qd, Qm, #n
         ///   A64: SHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n)
         ///   A32: VSHL.I64 Qd, Qm, #n
         ///   A64: SHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n)
         ///   A32: VSHL.I8 Qd, Qm, #n
         ///   A64: SHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHL.I16 Qd, Qm, #n
         ///   A64: SHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n)
@@ -13608,63 +13608,63 @@ internal Arm64() { }
         ///   A32: VSHL.I64 Qd, Qm, #n
         ///   A64: SHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n)
         ///   A32: VQSHL.U8 Dd, Dm, #n
         ///   A64: UQSHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n)
         ///   A32: VQSHL.S16 Dd, Dm, #n
         ///   A64: SQSHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n)
         ///   A32: VQSHL.S32 Dd, Dm, #n
         ///   A64: SQSHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n)
         ///   A32: VQSHL.S8 Dd, Dm, #n
         ///   A64: SQSHL Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n)
         ///   A32: VQSHL.U16 Dd, Dm, #n
         ///   A64: UQSHL Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n)
         ///   A32: VQSHL.U32 Dd, Dm, #n
         ///   A64: UQSHL Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VQSHL.U8 Qd, Qm, #n
         ///   A64: UQSHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHL.S16 Qd, Qm, #n
         ///   A64: SQSHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n)
@@ -13678,21 +13678,21 @@ internal Arm64() { }
         ///   A32: VQSHL.S64 Qd, Qm, #n
         ///   A64: SQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n)
         ///   A32: VQSHL.S8 Qd, Qm, #n
         ///   A64: SQSHL Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQSHL.U16 Qd, Qm, #n
         ///   A64: UQSHL Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n)
@@ -13706,49 +13706,49 @@ internal Arm64() { }
         ///   A32: VQSHL.U64 Qd, Qm, #n
         ///   A64: UQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n)
         ///   A32: VQSHL.S64 Dd, Dm, #n
         ///   A64: SQSHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+        public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
         /// <summary>
         /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n)
         ///   A32: VQSHL.U64 Dd, Dm, #n
         ///   A64: UQSHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+        public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateScalar(value, count);
 
         /// <summary>
         /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n)
         ///   A32: VQSHLU.S16 Dd, Dm, #n
         ///   A64: SQSHLU Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n)
         ///   A32: VQSHLU.S32 Dd, Dm, #n
         ///   A64: SQSHLU Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n)
         ///   A32: VQSHLU.S8 Dd, Dm, #n
         ///   A64: SQSHLU Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHLU.S16 Qd, Qm, #n
         ///   A64: SQSHLU Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n)
@@ -13762,91 +13762,91 @@ internal Arm64() { }
         ///   A32: VQSHLU.S64 Qd, Qm, #n
         ///   A64: SQSHLU Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n)
         ///   A32: VQSHLU.S8 Qd, Qm, #n
         ///   A64: SQSHLU Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n)
         ///   A32: VQSHLU.S64 Dd, Dm, #n
         ///   A64: SQSHLU Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+        public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
 
         /// <summary>
         /// int64x1_t vshl_n_s64 (int64x1_t a, const int n)
         ///   A32: VSHL.I64 Dd, Dm, #n
         ///   A64: SHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalScalar(value, count);
+        public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalScalar(value, count);
 
         /// <summary>
         /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n)
         ///   A32: VSHL.I64 Dd, Dm, #n
         ///   A64: SHL Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalScalar(value, count);
+        public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalScalar(value, count);
 
         /// <summary>
         /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHLL.U8 Qd, Dm, #n
         ///   A64: USHLL Vd.8H, Vn.8B, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningLower(value, count);
 
         /// <summary>
         /// int32x4_t vshll_n_s16 (int16x4_t a, const int n)
         ///   A32: VSHLL.S16 Qd, Dm, #n
         ///   A64: SSHLL Vd.4S, Vn.4H, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningLower(value, count);
 
         /// <summary>
         /// int64x2_t vshll_n_s32 (int32x2_t a, const int n)
         ///   A32: VSHLL.S32 Qd, Dm, #n
         ///   A64: SSHLL Vd.2D, Vn.2S, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningLower(value, count);
 
         /// <summary>
         /// int16x8_t vshll_n_s8 (int8x8_t a, const int n)
         ///   A32: VSHLL.S8 Qd, Dm, #n
         ///   A64: SSHLL Vd.8H, Vn.8B, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningLower(value, count);
 
         /// <summary>
         /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHLL.U16 Qd, Dm, #n
         ///   A64: USHLL Vd.4S, Vn.4H, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningLower(value, count);
 
         /// <summary>
         /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHLL.U32 Qd, Dm, #n
         ///   A64: USHLL Vd.2D, Vn.2S, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningLower(value, count);
 
         /// <summary>
         /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHLL.U8 Qd, Dm+1, #n
         ///   A64: USHLL2 Vd.8H, Vn.16B, #n
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHLL.S16 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.4S, Vn.8H, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n)
@@ -13860,14 +13860,14 @@ internal Arm64() { }
         ///   A32: VSHLL.S8 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.8H, Vn.16B, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHLL.U16 Qd, Dm+1, #n
         ///   A64: USHLL2 Vd.4S, Vn.8H, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n)
@@ -14329,56 +14329,56 @@ internal Arm64() { }
         ///   A32: VSRI.8 Dd, Dm, #n
         ///   A64: SRI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Dd, Dm, #n
         ///   A64: SRI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Dd, Dm, #n
         ///   A64: SRI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n))
         ///   A32: VSRI.8 Dd, Dm, #n
         ///   A64: SRI Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Dd, Dm, #n
         ///   A64: SRI Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Dd, Dm, #n
         ///   A64: SRI Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n))
         ///   A32: VSRI.8 Qd, Qm, #n
         ///   A64: SRI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Qd, Qm, #n
         ///   A64: SRI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
@@ -14392,21 +14392,21 @@ internal Arm64() { }
         ///   A32: VSRI.64 Qd, Qm, #n
         ///   A64: SRI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n))
         ///   A32: VSRI.8 Qd, Qm, #n
         ///   A64: SRI Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n))
         ///   A32: VSRI.16 Qd, Qm, #n
         ///   A64: SRI Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
@@ -14420,49 +14420,49 @@ internal Arm64() { }
         ///   A32: VSRI.64 Qd, Qm, #n
         ///   A64: SRI Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n))
         ///   A32: VSRI.64 Dd, Dm, #n
         ///   A64: SRI Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsertScalar(left, right, shift);
+        public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsertScalar(left, right, shift);
 
         /// <summary>
         /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n))
         ///   A32: VSRI.64 Dd, Dm, #n
         ///   A64: SRI Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsertScalar(left, right, shift);
+        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsertScalar(left, right, shift);
 
         /// <summary>
         /// int16x4_t vshr_n_s16 (int16x4_t a, const int n)
         ///   A32: VSHR.S16 Dd, Dm, #n
         ///   A64: SSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int32x2_t vshr_n_s32 (int32x2_t a, const int n)
         ///   A32: VSHR.S32 Dd, Dm, #n
         ///   A64: SSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int8x8_t vshr_n_s8 (int8x8_t a, const int n)
         ///   A32: VSHR.S8 Dd, Dm, #n
         ///   A64: SSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHR.S16 Qd, Qm, #n
         ///   A64: SSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n)
@@ -14476,42 +14476,42 @@ internal Arm64() { }
         ///   A32: VSHR.S64 Qd, Qm, #n
         ///   A64: SSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n)
         ///   A32: VSHR.S8 Qd, Qm, #n
         ///   A64: SSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n)
         ///   A32: VSRA.S16 Dd, Dm, #n
         ///   A64: SSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n)
         ///   A32: VSRA.S32 Dd, Dm, #n
         ///   A64: SSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n)
         ///   A32: VSRA.S8 Dd, Dm, #n
         ///   A64: SSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n)
         ///   A32: VSRA.S16 Qd, Qm, #n
         ///   A64: SSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
@@ -14525,133 +14525,133 @@ internal Arm64() { }
         ///   A32: VSRA.S64 Qd, Qm, #n
         ///   A64: SSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n)
         ///   A32: VSRA.S8 Qd, Qm, #n
         ///   A64: SSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n)
         ///   A32: VSRA.S64 Dd, Dm, #n
         ///   A64: SSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAddScalar(addend, value, count);
 
         /// <summary>
         /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHRN.S32 Dd, Qm, #n
         ///   A64: SQSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHRN.S64 Dd, Qm, #n
         ///   A64: SQSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHRN.S16 Dd, Qm, #n
         ///   A64: SQSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n)
         ///   A32: VQSHRUN.S16 Dd, Qm, #n
         ///   A64: SQSHRUN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
 
         /// <summary>
         /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHRUN.S32 Dd, Qm, #n
         ///   A64: SQSHRUN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
 
         /// <summary>
         /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHRUN.S64 Dd, Qm, #n
         ///   A64: SQSHRUN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
 
         /// <summary>
         /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n)
         ///   A32: VQSHRUN.S16 Dd+1, Dn, #n
         ///   A64: SQSHRUN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n)
         ///   A32: VQSHRUN.S32 Dd+1, Dn, #n
         ///   A64: SQSHRUN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n)
         ///   A32: VQSHRUN.S64 Dd+1, Dn, #n
         ///   A64: SQSHRUN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
 
         /// <summary>
         /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VQSHRN.S32 Dd+1, Qm, #n
         ///   A64: SQSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VQSHRN.S64 Dd+1, Qm, #n
         ///   A64: SQSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VQSHRN.S16 Dd+1, Qm, #n
         ///   A64: SQSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n)
         ///   A32: VRSHR.S16 Dd, Dm, #n
         ///   A64: SRSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n)
         ///   A32: VRSHR.S32 Dd, Dm, #n
         ///   A64: SRSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n)
         ///   A32: VRSHR.S8 Dd, Dm, #n
         ///   A64: SRSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n)
         ///   A32: VRSHR.S16 Qd, Qm, #n
         ///   A64: SRSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n)
@@ -14665,42 +14665,42 @@ internal Arm64() { }
         ///   A32: VRSHR.S64 Qd, Qm, #n
         ///   A64: SRSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n)
         ///   A32: VRSHR.S8 Qd, Qm, #n
         ///   A64: SRSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n)
         ///   A32: VRSRA.S16 Dd, Dm, #n
         ///   A64: SRSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n)
         ///   A32: VRSRA.S32 Dd, Dm, #n
         ///   A64: SRSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n)
         ///   A32: VRSRA.S8 Dd, Dm, #n
         ///   A64: SRSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n)
         ///   A32: VRSRA.S16 Qd, Qm, #n
         ///   A64: SRSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
@@ -14714,175 +14714,175 @@ internal Arm64() { }
         ///   A32: VRSRA.S64 Qd, Qm, #n
         ///   A64: SRSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n)
         ///   A32: VRSRA.S8 Qd, Qm, #n
         ///   A64: SRSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n)
         ///   A32: VRSRA.S64 Dd, Dm, #n
         ///   A64: SRSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAddScalar(addend, value, count);
 
         /// <summary>
         /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VQRSHRN.S32 Dd, Qm, #n
         ///   A64: SQRSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VQRSHRN.S64 Dd, Qm, #n
         ///   A64: SQRSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VQRSHRN.S16 Dd, Qm, #n
         ///   A64: SQRSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n)
         ///   A32: VQRSHRUN.S16 Dd, Qm, #n
         ///   A64: SQRSHRUN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
 
         /// <summary>
         /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n)
         ///   A32: VQRSHRUN.S32 Dd, Qm, #n
         ///   A64: SQRSHRUN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
 
         /// <summary>
         /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n)
         ///   A32: VQRSHRUN.S64 Dd, Qm, #n
         ///   A64: SQRSHRUN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
 
         /// <summary>
         /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n)
         ///   A32: VQRSHRUN.S16 Dd+1, Dn, #n
         ///   A64: SQRSHRUN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n)
         ///   A32: VQRSHRUN.S32 Dd+1, Dn, #n
         ///   A64: SQRSHRUN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n)
         ///   A32: VQRSHRUN.S64 Dd+1, Dn, #n
         ///   A64: SQRSHRUN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
 
         /// <summary>
         /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VQRSHRN.S32 Dd+1, Dn, #n
         ///   A64: SQRSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VQRSHRN.S64 Dd+1, Dn, #n
         ///   A64: SQRSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VQRSHRN.S16 Dd+1, Dn, #n
         ///   A64: SQRSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n)
         ///   A32: VRSHR.S64 Dd, Dm, #n
         ///   A64: SRSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedScalar(value, count);
+        public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedScalar(value, count);
 
         /// <summary>
         /// int64x1_t vshr_n_s64 (int64x1_t a, const int n)
         ///   A32: VSHR.S64 Dd, Dm, #n
         ///   A64: SSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticScalar(value, count);
+        public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticScalar(value, count);
 
         /// <summary>
         /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHR.U8 Dd, Dm, #n
         ///   A64: USHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
+        public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHR.U16 Dd, Dm, #n
         ///   A64: USHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogical(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count);
+        public static Vector64<short> ShiftRightLogical(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHR.U32 Dd, Dm, #n
         ///   A64: USHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogical(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
+        public static Vector64<int> ShiftRightLogical(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VSHR.U8 Dd, Dm, #n
         ///   A64: USHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
+        public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VSHR.U16 Dd, Dm, #n
         ///   A64: USHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count);
+        public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VSHR.U32 Dd, Dm, #n
         ///   A64: USHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
+        public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHR.U8 Qd, Qm, #n
         ///   A64: USHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogical(value, count);
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHR.U16 Qd, Qm, #n
         ///   A64: USHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
@@ -14896,21 +14896,21 @@ internal Arm64() { }
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VSHR.U8 Qd, Qm, #n
         ///   A64: USHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogical(value, count);
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHR.U16 Qd, Qm, #n
         ///   A64: USHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
@@ -14924,63 +14924,63 @@ internal Arm64() { }
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VSRA.U8 Dd, Dm, #n
         ///   A64: USRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VSRA.U16 Dd, Dm, #n
         ///   A64: USRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VSRA.U32 Dd, Dm, #n
         ///   A64: USRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VSRA.U8 Dd, Dm, #n
         ///   A64: USRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VSRA.U16 Dd, Dm, #n
         ///   A64: USRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VSRA.U32 Dd, Dm, #n
         ///   A64: USRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VSRA.U8 Qd, Qm, #n
         ///   A64: USRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VSRA.U16 Qd, Qm, #n
         ///   A64: USRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -14994,21 +14994,21 @@ internal Arm64() { }
         ///   A32: VSRA.U64 Qd, Qm, #n
         ///   A64: USRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VSRA.U8 Qd, Qm, #n
         ///   A64: USRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VSRA.U16 Qd, Qm, #n
         ///   A64: USRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -15022,245 +15022,245 @@ internal Arm64() { }
         ///   A32: VSRA.U64 Qd, Qm, #n
         ///   A64: USRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VSRA.U64 Dd, Dm, #n
         ///   A64: USRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAddScalar(addend, value, count);
 
         /// <summary>
         /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VSRA.U64 Dd, Dm, #n
         ///   A64: USRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAddScalar(addend, value, count);
+        public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAddScalar(addend, value, count);
 
         /// <summary>
         /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd, Qm, #n
         ///   A64: SHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
 
         /// <summary>
         /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd, Qm, #n
         ///   A64: SHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
 
         /// <summary>
         /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd, Qm, #n
         ///   A64: SHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
 
         /// <summary>
         /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd, Qm, #n
         ///   A64: SHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
 
         /// <summary>
         /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd, Qm, #n
         ///   A64: SHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
 
         /// <summary>
         /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd, Qm, #n
         ///   A64: SHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingLower(value, count);
 
         /// <summary>
         /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd, Qm, #n
         ///   A64: UQSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd, Qm, #n
         ///   A64: UQSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd, Qm, #n
         ///   A64: UQSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd, Qm, #n
         ///   A64: UQSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd, Qm, #n
         ///   A64: UQSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd, Qm, #n
         ///   A64: UQSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VQSHRN.U16 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VQSHRN.U32 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VQSHRN.U64 Dd+1, Qm, #n
         ///   A64: UQSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VSHRN.I16 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VSHRN.I32 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VSHRN.I64 Dd+1, Qm, #n
         ///   A64: SHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VRSHR.U8 Dd, Dm, #n
         ///   A64: URSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VRSHR.U16 Dd, Dm, #n
         ///   A64: URSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VRSHR.U32 Dd, Dm, #n
         ///   A64: URSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n)
         ///   A32: VRSHR.U8 Dd, Dm, #n
         ///   A64: URSHR Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n)
         ///   A32: VRSHR.U16 Dd, Dm, #n
         ///   A64: URSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n)
         ///   A32: VRSHR.U32 Dd, Dm, #n
         ///   A64: URSHR Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VRSHR.U8 Qd, Qm, #n
         ///   A64: URSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VRSHR.U16 Qd, Qm, #n
         ///   A64: URSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
@@ -15274,21 +15274,21 @@ internal Arm64() { }
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n)
         ///   A32: VRSHR.U8 Qd, Qm, #n
         ///   A64: URSHR Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n)
         ///   A32: VRSHR.U16 Qd, Qm, #n
         ///   A64: URSHR Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
@@ -15302,63 +15302,63 @@ internal Arm64() { }
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VRSRA.U8 Dd, Dm, #n
         ///   A64: URSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VRSRA.U16 Dd, Dm, #n
         ///   A64: URSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VRSRA.U32 Dd, Dm, #n
         ///   A64: URSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n)
         ///   A32: VRSRA.U8 Dd, Dm, #n
         ///   A64: URSRA Vd.8B, Vn.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VRSRA.U16 Dd, Dm, #n
         ///   A64: URSRA Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VRSRA.U32 Dd, Dm, #n
         ///   A64: URSRA Vd.2S, Vn.2S, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VRSRA.U8 Qd, Qm, #n
         ///   A64: URSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VRSRA.U16 Qd, Qm, #n
         ///   A64: URSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -15372,21 +15372,21 @@ internal Arm64() { }
         ///   A32: VRSRA.U64 Qd, Qm, #n
         ///   A64: URSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VRSRA.U8 Qd, Qm, #n
         ///   A64: URSRA Vd.16B, Vn.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VRSRA.U16 Qd, Qm, #n
         ///   A64: URSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
@@ -15400,70 +15400,70 @@ internal Arm64() { }
         ///   A32: VRSRA.U64 Qd, Qm, #n
         ///   A64: URSRA Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VRSRA.U64 Dd, Dm, #n
         ///   A64: URSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count);
 
         /// <summary>
         /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n)
         ///   A32: VRSRA.U64 Dd, Dm, #n
         ///   A64: URSRA Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count);
+        public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count);
 
         /// <summary>
         /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd, Qm, #n
         ///   A64: RSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
 
         /// <summary>
         /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd, Qm, #n
         ///   A64: RSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
 
         /// <summary>
         /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd, Qm, #n
         ///   A64: RSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
 
         /// <summary>
         /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd, Qm, #n
         ///   A64: RSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
 
         /// <summary>
         /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd, Qm, #n
         ///   A64: RSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
 
         /// <summary>
         /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd, Qm, #n
         ///   A64: RSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
 
         /// <summary>
         /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n)
         ///   A32: VQRSHRN.U16 Dd, Qm, #n
         ///   A64: UQRSHRN Vd.8B, Vn.8H, #n
         /// </summary>
-        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n)
@@ -15471,7 +15471,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN Vd.4H, Vn.4S, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n)
@@ -15479,7 +15479,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN Vd.2S, Vn.2D, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n)
@@ -15487,28 +15487,28 @@ internal Arm64() { }
         ///   A64: UQRSHRN Vd.8B, Vn.8H, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQRSHRN.U32 Dd, Qm, #n
         ///   A64: UQRSHRN Vd.4H, Vn.4S, #n
         /// </summary>
-        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQRSHRN.U64 Dd, Qm, #n
         ///   A64: UQRSHRN Vd.2S, Vn.2D, #n
         /// </summary>
-        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
 
         /// <summary>
         /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VQRSHRN.U16 Dd+1, Dn, #n
         ///   A64: UQRSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
@@ -15516,7 +15516,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
@@ -15524,7 +15524,7 @@ internal Arm64() { }
         ///   A64: UQRSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
@@ -15532,91 +15532,91 @@ internal Arm64() { }
         ///   A64: UQRSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
         [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
-        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VQRSHRN.U32 Dd+1, Dn, #n
         ///   A64: UQRSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VQRSHRN.U64 Dd+1, Dn, #n
         ///   A64: UQRSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
 
         /// <summary>
         /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n)
         ///   A32: VRSHRN.I16 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.16B, Vn.8H, #n
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n)
         ///   A32: VRSHRN.I32 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.8H, Vn.4S, #n
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n)
         ///   A32: VRSHRN.I64 Dd+1, Qm, #n
         ///   A64: RSHRN2 Vd.4S, Vn.2D, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
 
         /// <summary>
         /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VRSHR.U64 Dd, Dm, #n
         ///   A64: URSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedScalar(value, count);
+        public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedScalar(value, count);
 
         /// <summary>
         /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VRSHR.U64 Dd, Dm, #n
         ///   A64: URSHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedScalar(value, count);
+        public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedScalar(value, count);
 
         /// <summary>
         /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VSHR.U64 Dd, Dm, #n
         ///   A64: USHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalScalar(value, count);
+        public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalScalar(value, count);
 
         /// <summary>
         /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n)
         ///   A32: VSHR.U64 Dd, Dm, #n
         ///   A64: USHR Dd, Dn, #n
         /// </summary>
-        public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalScalar(value, count);
+        public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalScalar(value, count);
 
         /// <summary>
         /// int32x4_t vmovl_s16 (int16x4_t a)

From 3c355f41b6ecc2b0325f79d27ee3b80a00df7b7d Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 17 Jun 2024 10:29:03 -0700
Subject: [PATCH 3/4] Ensure the reference assembly is also updated

---
 .../Arm/AdvSimd.PlatformNotSupported.cs       |   4 +-
 .../System/Runtime/Intrinsics/Arm/AdvSimd.cs  |   4 +-
 .../ref/System.Runtime.Intrinsics.cs          | 526 +++++++++---------
 3 files changed, 267 insertions(+), 267 deletions(-)

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 d59bc76620e4c..a45dfb787bf05 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
@@ -14632,7 +14632,7 @@ internal Arm64() { }
         ///   A32: VRSHR.S16 Dd, Dm, #n
         ///   A64: SRSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n)
@@ -14702,7 +14702,7 @@ internal Arm64() { }
         ///   A32: VRSRA.S16 Qd, Qm, #n
         ///   A64: SRSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
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 1f5c1177f26b9..ef44ef55ed772 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
@@ -14630,7 +14630,7 @@ internal Arm64() { }
         ///   A32: VRSHR.S16 Dd, Dm, #n
         ///   A64: SRSHR Vd.4H, Vn.4H, #n
         /// </summary>
-        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n)
@@ -14700,7 +14700,7 @@ internal Arm64() { }
         ///   A32: VRSRA.S16 Qd, Qm, #n
         ///   A64: SRSRA Vd.8H, Vn.8H, #n
         /// </summary>
-        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
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 3e85d1af8d583..dff493a19faa5 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -2592,72 +2592,72 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftArithmeticSaturate(System.Runtime.Intrinsics.Vector64<sbyte> value, System.Runtime.Intrinsics.Vector64<sbyte> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<long> ShiftArithmeticSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<long> ShiftArithmeticScalar(System.Runtime.Intrinsics.Vector64<long> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> ShiftLogical(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<sbyte> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> ShiftLogical(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
@@ -2723,196 +2723,196 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<long> ShiftLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, System.Runtime.Intrinsics.Vector64<long> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticRoundedAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticRoundedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticRoundedAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticRoundedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<byte> addend, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<byte> addend, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(128))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<byte> addend, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<byte> addend, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
         [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
         [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
         [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
         [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
         [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(64))] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector64<short> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector64<int> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> SignExtendWideningLower(System.Runtime.Intrinsics.Vector64<sbyte> value) { throw null; }
@@ -3705,15 +3705,15 @@ internal Arm64() { }
             public static System.Runtime.Intrinsics.Vector64<short> ShiftArithmeticSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, System.Runtime.Intrinsics.Vector64<short> count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> ShiftArithmeticSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, System.Runtime.Intrinsics.Vector64<int> count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftArithmeticSaturateScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, System.Runtime.Intrinsics.Vector64<sbyte> count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<byte> ShiftLogicalRoundedSaturateScalar(System.Runtime.Intrinsics.Vector64<byte> value, System.Runtime.Intrinsics.Vector64<sbyte> count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> ShiftLogicalRoundedSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, System.Runtime.Intrinsics.Vector64<short> count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> ShiftLogicalRoundedSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, System.Runtime.Intrinsics.Vector64<int> count) { throw null; }
@@ -3726,33 +3726,33 @@ internal Arm64() { }
             public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, System.Runtime.Intrinsics.Vector64<sbyte> count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, System.Runtime.Intrinsics.Vector64<short> count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<uint> ShiftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, System.Runtime.Intrinsics.Vector64<int> count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
             [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
             public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
             [System.Obsolete("The underlying hardware instruction does not perform a signed saturate narrowing operation, and it always returns an unsigned result. Use the unsigned overload instead.", DiagnosticId = "SYSLIB0055", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(16))] byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(8))] byte count) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = 1, Max = (byte)(32))] byte count) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> Sqrt(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> Sqrt(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<float> Sqrt(System.Runtime.Intrinsics.Vector64<float> value) { throw null; }
@@ -4211,7 +4211,7 @@ internal Arm64() { }
         public static System.Numerics.Vector<float> AbsoluteDifference(System.Numerics.Vector<float> left, System.Numerics.Vector<float> right) { throw null; }
         public static System.Numerics.Vector<ushort> AbsoluteDifference(System.Numerics.Vector<ushort> left, System.Numerics.Vector<ushort> right) { throw null; }
         public static System.Numerics.Vector<uint> AbsoluteDifference(System.Numerics.Vector<uint> left, System.Numerics.Vector<uint> right) { throw null; }
-        public static System.Numerics.Vector<ulong> AbsoluteDifference(System.Numerics.Vector<ulong> left, System.Numerics.Vector<ulong> right) { throw null; }        
+        public static System.Numerics.Vector<ulong> AbsoluteDifference(System.Numerics.Vector<ulong> left, System.Numerics.Vector<ulong> right) { throw null; }
 
         public static System.Numerics.Vector<sbyte> Add(System.Numerics.Vector<sbyte> left, System.Numerics.Vector<sbyte> right) { throw null; }
         public static System.Numerics.Vector<short> Add(System.Numerics.Vector<short> left, System.Numerics.Vector<short> right) { throw null; }
@@ -4389,7 +4389,7 @@ internal Arm64() { }
         public static System.Numerics.Vector<int> DotProductBySelectedScalar(System.Numerics.Vector<int> addend, System.Numerics.Vector<sbyte> left, System.Numerics.Vector<sbyte> right, [ConstantExpected] byte rightIndex) { throw null; }
         public static System.Numerics.Vector<long> DotProductBySelectedScalar(System.Numerics.Vector<long> addend, System.Numerics.Vector<short> left, System.Numerics.Vector<short> right, [ConstantExpected] byte rightIndex) { throw null; }
         public static System.Numerics.Vector<uint> DotProductBySelectedScalar(System.Numerics.Vector<uint> addend, System.Numerics.Vector<byte> left, System.Numerics.Vector<byte> right, [ConstantExpected] byte rightIndex) { throw null; }
-        public static System.Numerics.Vector<ulong> DotProductBySelectedScalar(System.Numerics.Vector<ulong> addend, System.Numerics.Vector<ushort> left, System.Numerics.Vector<ushort> right, [ConstantExpected] byte rightIndex) { throw null; }        
+        public static System.Numerics.Vector<ulong> DotProductBySelectedScalar(System.Numerics.Vector<ulong> addend, System.Numerics.Vector<ushort> left, System.Numerics.Vector<ushort> right, [ConstantExpected] byte rightIndex) { throw null; }
 
         public static System.Numerics.Vector<double> FusedMultiplyAdd(System.Numerics.Vector<double> addend, System.Numerics.Vector<double> left, System.Numerics.Vector<double> right) { throw null; }
         public static System.Numerics.Vector<float> FusedMultiplyAdd(System.Numerics.Vector<float> addend, System.Numerics.Vector<float> left, System.Numerics.Vector<float> right) { throw null; }
@@ -4552,7 +4552,7 @@ internal Arm64() { }
         public static unsafe System.Numerics.Vector<ulong> LoadVector(System.Numerics.Vector<ulong> mask, ulong* address) { throw null; }
         public static unsafe System.Numerics.Vector<float> LoadVector(System.Numerics.Vector<float> mask, float* address) { throw null; }
         public static unsafe System.Numerics.Vector<double> LoadVector(System.Numerics.Vector<double> mask, double* address) { throw null; }
-        
+
         public static unsafe System.Numerics.Vector<byte> LoadVectorNonFaulting(byte* address) { throw null; }
         public static unsafe System.Numerics.Vector<double> LoadVectorNonFaulting(double* address) { throw null; }
         public static unsafe System.Numerics.Vector<short> LoadVectorNonFaulting(short* address) { throw null; }
@@ -4736,13 +4736,13 @@ internal Arm64() { }
         public static System.Numerics.Vector<ushort> MultiplyAdd(System.Numerics.Vector<ushort> addend, System.Numerics.Vector<ushort> left, System.Numerics.Vector<ushort> right) { throw null; }
         public static System.Numerics.Vector<uint> MultiplyAdd(System.Numerics.Vector<uint> addend, System.Numerics.Vector<uint> left, System.Numerics.Vector<uint> right) { throw null; }
         public static System.Numerics.Vector<ulong> MultiplyAdd(System.Numerics.Vector<ulong> addend, System.Numerics.Vector<ulong> left, System.Numerics.Vector<ulong> right) { throw null; }
-        
+
         public static System.Numerics.Vector<double> MultiplyBySelectedScalar(System.Numerics.Vector<double> left, System.Numerics.Vector<double> right, [ConstantExpected] byte rightIndex) { throw null; }
         public static System.Numerics.Vector<float> MultiplyBySelectedScalar(System.Numerics.Vector<float> left, System.Numerics.Vector<float> right, [ConstantExpected] byte rightIndex) { throw null; }
-        
+
         public static System.Numerics.Vector<double> MultiplyExtended(System.Numerics.Vector<double> left, System.Numerics.Vector<double> right) { throw null; }
         public static System.Numerics.Vector<float> MultiplyExtended(System.Numerics.Vector<float> left, System.Numerics.Vector<float> right) { throw null; }
-        
+
         public static System.Numerics.Vector<byte> MultiplySubtract(System.Numerics.Vector<byte> minuend, System.Numerics.Vector<byte> left, System.Numerics.Vector<byte> right) { throw null; }
         public static System.Numerics.Vector<short> MultiplySubtract(System.Numerics.Vector<short> minuend, System.Numerics.Vector<short> left, System.Numerics.Vector<short> right) { throw null; }
         public static System.Numerics.Vector<int> MultiplySubtract(System.Numerics.Vector<int> minuend, System.Numerics.Vector<int> left, System.Numerics.Vector<int> right) { throw null; }
@@ -4750,7 +4750,7 @@ internal Arm64() { }
         public static System.Numerics.Vector<sbyte> MultiplySubtract(System.Numerics.Vector<sbyte> minuend, System.Numerics.Vector<sbyte> left, System.Numerics.Vector<sbyte> right) { throw null; }
         public static System.Numerics.Vector<ushort> MultiplySubtract(System.Numerics.Vector<ushort> minuend, System.Numerics.Vector<ushort> left, System.Numerics.Vector<ushort> right) { throw null; }
         public static System.Numerics.Vector<uint> MultiplySubtract(System.Numerics.Vector<uint> minuend, System.Numerics.Vector<uint> left, System.Numerics.Vector<uint> right) { throw null; }
-        public static System.Numerics.Vector<ulong> MultiplySubtract(System.Numerics.Vector<ulong> minuend, System.Numerics.Vector<ulong> left, System.Numerics.Vector<ulong> right) { throw null; }        
+        public static System.Numerics.Vector<ulong> MultiplySubtract(System.Numerics.Vector<ulong> minuend, System.Numerics.Vector<ulong> left, System.Numerics.Vector<ulong> right) { throw null; }
 
         public static System.Numerics.Vector<double> Negate(System.Numerics.Vector<double> value) { throw null; }
         public static System.Numerics.Vector<short> Negate(System.Numerics.Vector<short> value) { throw null; }
@@ -6295,7 +6295,7 @@ internal Avx10v1() { }
             internal X64() { }
             public static new bool IsSupported { get { throw null; } }
             public static System.Runtime.Intrinsics.Vector128<double> ConvertScalarToVector128Double(System.Runtime.Intrinsics.Vector128<double> upper, ulong value) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> ConvertScalarToVector128Single(System.Runtime.Intrinsics.Vector128<float> upper, ulong value) { throw null; }            
+            public static System.Runtime.Intrinsics.Vector128<float> ConvertScalarToVector128Single(System.Runtime.Intrinsics.Vector128<float> upper, ulong value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> ConvertScalarToVector128Double(System.Runtime.Intrinsics.Vector128<double> upper, ulong value, [System.Diagnostics.CodeAnalysis.ConstantExpected(Max = System.Runtime.Intrinsics.X86.FloatRoundingMode.ToZero)] System.Runtime.Intrinsics.X86.FloatRoundingMode mode) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> ConvertScalarToVector128Single(System.Runtime.Intrinsics.Vector128<float> upper, ulong value, [System.Diagnostics.CodeAnalysis.ConstantExpected(Max = System.Runtime.Intrinsics.X86.FloatRoundingMode.ToZero)] System.Runtime.Intrinsics.X86.FloatRoundingMode mode) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> ConvertScalarToVector128Double(System.Runtime.Intrinsics.Vector128<double> upper, long value, [System.Diagnostics.CodeAnalysis.ConstantExpected(Max = System.Runtime.Intrinsics.X86.FloatRoundingMode.ToZero)] System.Runtime.Intrinsics.X86.FloatRoundingMode mode) { throw null; }
@@ -7528,7 +7528,7 @@ internal VL() { }
             internal X64() { }
             public static new bool IsSupported { get { throw null; } }
             public static System.Runtime.Intrinsics.Vector128<double> ConvertScalarToVector128Double(System.Runtime.Intrinsics.Vector128<double> upper, ulong value) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> ConvertScalarToVector128Single(System.Runtime.Intrinsics.Vector128<float> upper, ulong value) { throw null; }            
+            public static System.Runtime.Intrinsics.Vector128<float> ConvertScalarToVector128Single(System.Runtime.Intrinsics.Vector128<float> upper, ulong value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> ConvertScalarToVector128Double(System.Runtime.Intrinsics.Vector128<double> upper, ulong value, [System.Diagnostics.CodeAnalysis.ConstantExpected(Max = System.Runtime.Intrinsics.X86.FloatRoundingMode.ToZero)] System.Runtime.Intrinsics.X86.FloatRoundingMode mode) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> ConvertScalarToVector128Single(System.Runtime.Intrinsics.Vector128<float> upper, ulong value, [System.Diagnostics.CodeAnalysis.ConstantExpected(Max = System.Runtime.Intrinsics.X86.FloatRoundingMode.ToZero)] System.Runtime.Intrinsics.X86.FloatRoundingMode mode) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> ConvertScalarToVector128Double(System.Runtime.Intrinsics.Vector128<double> upper, long value, [System.Diagnostics.CodeAnalysis.ConstantExpected(Max = System.Runtime.Intrinsics.X86.FloatRoundingMode.ToZero)] System.Runtime.Intrinsics.X86.FloatRoundingMode mode) { throw null; }

From 689db995d2b264123a2807b74af2560054525bcd Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 17 Jun 2024 11:44:41 -0700
Subject: [PATCH 4/4] Update the supression file for net8 vs net9

---
 ...iCompatBaseline.NetCoreAppLatestStable.xml | 1524 +++++++++++++++++
 1 file changed, 1524 insertions(+)

diff --git a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml
index 05336ecc0ae91..2ce9abc316b77 100644
--- a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml
+++ b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml
@@ -469,6 +469,1530 @@
     <Left>net8.0/System.dll</Left>
     <Right>net9.0/System.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128{System.Byte},System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128{System.Int64},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128{System.SByte},System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogical(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128{System.Byte},System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128{System.Int64},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128{System.SByte},System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128{System.Int64},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128{System.SByte},System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticAddScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128{System.Int64},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128{System.SByte},System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedAddScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticRoundedScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightArithmeticScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogical(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128{System.Byte},System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128{System.Int64},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128{System.SByte},System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128{System.Byte},System.Runtime.Intrinsics.Vector128{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128{System.Int64},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128{System.SByte},System.Runtime.Intrinsics.Vector128{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector64{System.Byte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector64{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector64{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector64{System.SByte},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector64{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector64{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.Byte},System.Runtime.Intrinsics.Vector128{System.UInt16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.Int16},System.Runtime.Intrinsics.Vector128{System.Int32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.Int32},System.Runtime.Intrinsics.Vector128{System.Int64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.SByte},System.Runtime.Intrinsics.Vector128{System.Int16},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.UInt16},System.Runtime.Intrinsics.Vector128{System.UInt32},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64{System.UInt32},System.Runtime.Intrinsics.Vector128{System.UInt64},System.Byte)$2:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64{System.Int64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>M:System.Runtime.Intrinsics.Arm.AdvSimd.ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64{System.UInt64},System.Byte)$1:[T:System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute]</Target>
+    <Left>net8.0/System.Runtime.Intrinsics.dll</Left>
+    <Right>net9.0/System.Runtime.Intrinsics.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0015</DiagnosticId>
     <Target>T:System.Text.RegularExpressions.GeneratedRegexAttribute:[T:System.AttributeUsageAttribute]</Target>