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 d53236e7116da8..c2727e85174519 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
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.Arm
@@ -55,25 +56,25 @@ internal AdvSimd() { }
         //     /// float32x2_t vmla_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLA.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float32x2_t vmla_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLA.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float32x4_t vmlaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLA.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float32x4_t vmlaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLA.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float64x1_t vmla_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
@@ -116,25 +117,25 @@ internal AdvSimd() { }
         //     /// float32x2_t vmls_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLS.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float32x2_t vmls_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLS.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float32x4_t vmlsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLS.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float32x4_t vmlsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLS.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         //
         //     /// <summary>
         //     /// float64x1_t vmls_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
@@ -1127,19 +1128,19 @@ internal Arm64() { }
             /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane)
             ///   A64: DUP Vd.2D, Vn.D[index]
             /// </summary>
-            public static Vector128<double> DuplicateSelectedScalarToVector128(Vector128<double> value, byte index) { throw new PlatformNotSupportedException(); }
+            public static Vector128<double> DuplicateSelectedScalarToVector128(Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane)
             ///   A64: DUP Vd.2D, Vn.D[index]
             /// </summary>
-            public static Vector128<long> DuplicateSelectedScalarToVector128(Vector128<long> value, byte index) { throw new PlatformNotSupportedException(); }
+            public static Vector128<long> DuplicateSelectedScalarToVector128(Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane)
             ///   A64: DUP Vd.2D, Vn.D[index]
             /// </summary>
-            public static Vector128<ulong> DuplicateSelectedScalarToVector128(Vector128<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+            public static Vector128<ulong> DuplicateSelectedScalarToVector128(Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vdupq_n_f64 (float64_t value)
@@ -1247,49 +1248,49 @@ internal Arm64() { }
             /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
             ///   A64: FMLA Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
             ///   A64: FMLA Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane)
             ///   A64: FMLA Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> FusedMultiplyAddBySelectedScalar(Vector128<double> addend, Vector128<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<double> FusedMultiplyAddBySelectedScalar(Vector128<double> addend, Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
             ///   A64: FMLA Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
             ///   A64: FMLA Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane)
             ///   A64: FMLA Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> FusedMultiplyAddScalarBySelectedScalar(Vector64<double> addend, Vector64<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<double> FusedMultiplyAddScalarBySelectedScalar(Vector64<double> addend, Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane)
             ///   A64: FMLA Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane)
             ///   A64: FMLA Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
@@ -1319,235 +1320,235 @@ internal Arm64() { }
             /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
             ///   A64: FMLS Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
             ///   A64: FMLS Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane)
             ///   A64: FMLS Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> FusedMultiplySubtractBySelectedScalar(Vector128<double> minuend, Vector128<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<double> FusedMultiplySubtractBySelectedScalar(Vector128<double> minuend, Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
             ///   A64: FMLS Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
             ///   A64: FMLS Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane)
             ///   A64: FMLS Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(Vector64<double> minuend, Vector64<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(Vector64<double> minuend, Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane)
             ///   A64: FMLS Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane)
             ///   A64: FMLS Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, byte resultIndex, Vector64<byte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, byte resultIndex, Vector128<byte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, byte resultIndex, Vector64<short> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, byte resultIndex, Vector128<short> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, byte resultIndex, Vector64<int> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, byte resultIndex, Vector128<int> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, byte resultIndex, Vector64<sbyte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, byte resultIndex, Vector128<sbyte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, byte resultIndex, Vector64<float> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, byte resultIndex, Vector128<float> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, byte resultIndex, Vector64<ushort> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, byte resultIndex, Vector128<ushort> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, byte resultIndex, Vector64<uint> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, byte resultIndex, Vector128<uint> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, byte resultIndex, Vector64<byte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, byte resultIndex, Vector128<byte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2)
             ///   A64: INS Vd.D[lane1], Vn.D[lane2]
             /// </summary>
-            public static Vector128<double> InsertSelectedScalar(Vector128<double> result, byte resultIndex, Vector128<double> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<double> InsertSelectedScalar(Vector128<double> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, byte resultIndex, Vector64<short> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, byte resultIndex, Vector128<short> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, byte resultIndex, Vector64<int> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, byte resultIndex, Vector128<int> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2)
             ///   A64: INS Vd.D[lane1], Vn.D[lane2]
             /// </summary>
-            public static Vector128<long> InsertSelectedScalar(Vector128<long> result, byte resultIndex, Vector128<long> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<long> InsertSelectedScalar(Vector128<long> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, byte resultIndex, Vector64<sbyte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, byte resultIndex, Vector128<sbyte> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, byte resultIndex, Vector64<float> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, byte resultIndex, Vector128<float> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, byte resultIndex, Vector64<ushort> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, byte resultIndex, Vector128<ushort> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, byte resultIndex, Vector64<uint> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, byte resultIndex, Vector128<uint> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2)
             ///   A64: INS Vd.D[lane1], Vn.D[lane2]
             /// </summary>
-            public static Vector128<ulong> InsertSelectedScalar(Vector128<ulong> result, byte resultIndex, Vector128<ulong> value, byte valueIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<ulong> InsertSelectedScalar(Vector128<ulong> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vld1q_dup_f64 (float64_t const * ptr)
@@ -2187,7 +2188,7 @@ internal Arm64() { }
             /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane)
             ///   A64: FMUL Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> MultiplyBySelectedScalar(Vector128<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<double> MultiplyBySelectedScalar(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqdmulhh_s16 (int16_t a, int16_t b)
@@ -2205,25 +2206,25 @@ internal Arm64() { }
             /// int16_t vqdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane)
             ///   A64: SQDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane)
             ///   A64: SQDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane)
             ///   A64: SQDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane)
             ///   A64: SQDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmlalh_s16 (int32_t a, int16_t b, int16_t c)
@@ -2265,73 +2266,73 @@ internal Arm64() { }
             /// int32_t vqdmullh_lane_s16 (int16_t a, int16x4_t v, const int lane)
             ///   A64: SQDMULL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmullh_laneq_s16 (int16_t a, int16x8_t v, const int lane)
             ///   A64: SQDMULL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64_t vqdmulls_lane_s32 (int32_t a, int32x2_t v, const int lane)
             ///   A64: SQDMULL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64_t vqdmulls_laneq_s32 (int32_t a, int32x4_t v, const int lane)
             ///   A64: SQDMULL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmlalh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQDMLAL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmlalh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQDMLAL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64_t vqdmlals_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQDMLAL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64_t vqdmlals_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQDMLAL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmlslh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQDMLSL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqdmlslh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQDMLSL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64_t vqdmlsls_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQDMLSL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int64_t vqdmlsls_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQDMLSL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b)
@@ -2361,31 +2362,31 @@ internal Arm64() { }
             /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane)
             ///   A64: FMULX Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane)
             ///   A64: FMULX Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane)
             ///   A64: FMULX Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> MultiplyExtendedBySelectedScalar(Vector128<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<double> MultiplyExtendedBySelectedScalar(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane)
             ///   A64: FMULX Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane)
             ///   A64: FMULX Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b)
@@ -2403,19 +2404,19 @@ internal Arm64() { }
             /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane)
             ///   A64: FMULX Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> MultiplyExtendedScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<double> MultiplyExtendedScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane)
             ///   A64: FMULX Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane)
             ///   A64: FMULX Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrdmulhh_s16 (int16_t a, int16_t b)
@@ -2433,31 +2434,31 @@ internal Arm64() { }
             /// int16_t vqrdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane)
             ///   A64: SQRDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane)
             ///   A64: SQRDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqrdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane)
             ///   A64: SQRDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqrdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane)
             ///   A64: SQRDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane)
             ///   A64: FMUL Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> MultiplyScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<double> MultiplyScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float64x2_t vnegq_f64 (float64x2_t a)
@@ -2661,55 +2662,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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b)
@@ -2787,145 +2788,145 @@ internal Arm64() { }
             /// int16_t vqshrns_n_s32 (int32_t a, const int n)
             ///   A64: SQSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<int> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshruns_n_s32 (int32_t a, const int n)
             ///   A64: SQSHRUN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<int> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrshrns_n_s32 (int32_t a, const int n)
             ///   A64: SQRSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<int> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqrshruns_n_s32 (int32_t a, const int n)
             ///   A64: SQRSHRUN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<int> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(Vector64<int> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(Vector64<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQRSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<int> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQRSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQRSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// 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, byte count) { throw new PlatformNotSupportedException(); }
+            public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// float32x2_t vsqrt_f32 (float32x2_t a)
@@ -3665,7 +3666,7 @@ internal Arm64() { }
             ///  uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx)
             ///   A64: TBX Vd.16B, {Vn.16B}, Vm.16B
             /// </summary>
-            public static Vector128<byte> VectorTableLookupExtension(Vector128<byte> defaultValues, Vector128<byte> table, Vector128<byte>  byteIndexes) { throw new PlatformNotSupportedException(); }
+            public static Vector128<byte> VectorTableLookupExtension(Vector128<byte> defaultValues, Vector128<byte> table, Vector128<byte> byteIndexes) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             ///  int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx)
@@ -6522,196 +6523,196 @@ internal Arm64() { }
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector64<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector64<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector64<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector64<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane)
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector64<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector64<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector64<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane)
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector128<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector128<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector128<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector128<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane)
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector128<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector128<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector128<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vdupq_lane_u8 (uint8x8_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector64<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vdupq_lane_s16 (int16x4_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector64<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vdupq_lane_s32 (int32x2_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector64<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector64<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vdupq_lane_s8 (int8x8_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector64<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vdupq_lane_u16 (uint16x4_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector64<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vdupq_lane_u32 (uint32x2_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector64<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector128<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector128<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector128<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vdupq_lane_f32 (float32x4_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector128<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector128<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector128<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector128<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vdup_n_u8 (uint8_t value)
@@ -6816,119 +6817,119 @@ internal Arm64() { }
         ///   A32: VMOV.U8 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.B[lane]
         /// </summary>
-        public static byte Extract(Vector64<byte> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static byte Extract(Vector64<byte> vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16_t vget_lane_s16 (int16x4_t v, const int lane)
         ///   A32: VMOV.S16 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.H[lane]
         /// </summary>
-        public static short Extract(Vector64<short> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static short Extract(Vector64<short> vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32_t vget_lane_s32 (int32x2_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.S[lane]
         /// </summary>
-        public static int Extract(Vector64<int> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static int Extract(Vector64<int> vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8_t vget_lane_s8 (int8x8_t v, const int lane)
         ///   A32: VMOV.S8 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.B[lane]
         /// </summary>
-        public static sbyte Extract(Vector64<sbyte> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static sbyte Extract(Vector64<sbyte> vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32_t vget_lane_f32 (float32x2_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: DUP Sd, Vn.S[lane]
         /// </summary>
-        public static float Extract(Vector64<float> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static float Extract(Vector64<float> vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane)
         ///   A32: VMOV.U16 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.H[lane]
         /// </summary>
-        public static ushort Extract(Vector64<ushort> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static ushort Extract(Vector64<ushort> vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.S[lane]
         /// </summary>
-        public static uint Extract(Vector64<uint> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static uint Extract(Vector64<uint> vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane)
         ///   A32: VMOV.U8 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.B[lane]
         /// </summary>
-        public static byte Extract(Vector128<byte> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static byte Extract(Vector128<byte> vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane)
         ///   A32: VMOV.F64 Dd, Dm
         ///   A64: DUP Dd, Vn.D[lane]
         /// </summary>
-        public static double Extract(Vector128<double> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static double Extract(Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane)
         ///   A32: VMOV.S16 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.H[lane]
         /// </summary>
-        public static short Extract(Vector128<short> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static short Extract(Vector128<short> vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.S[lane]
         /// </summary>
-        public static int Extract(Vector128<int> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static int Extract(Vector128<int> vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane)
         ///   A32: VMOV Rt, Rt2, Dm
         ///   A64: UMOV Xd, Vn.D[lane]
         /// </summary>
-        public static long Extract(Vector128<long> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static long Extract(Vector128<long> vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane)
         ///   A32: VMOV.S8 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.B[lane]
         /// </summary>
-        public static sbyte Extract(Vector128<sbyte> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static sbyte Extract(Vector128<sbyte> vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: DUP Sd, Vn.S[lane]
         /// </summary>
-        public static float Extract(Vector128<float> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static float Extract(Vector128<float> vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane)
         ///   A32: VMOV.U16 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.H[lane]
         /// </summary>
-        public static ushort Extract(Vector128<ushort> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static ushort Extract(Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.S[lane]
         /// </summary>
-        public static uint Extract(Vector128<uint> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static uint Extract(Vector128<uint> vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane)
         ///   A32: VMOV Rt, Rt2, Dm
         ///   A64: UMOV Xd, Vn.D[lane]
         /// </summary>
-        public static ulong Extract(Vector128<ulong> vector, byte index) { throw new PlatformNotSupportedException(); }
+        public static ulong Extract(Vector128<ulong> vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vmovn_u16 (uint16x8_t a)
@@ -7145,119 +7146,119 @@ internal Arm64() { }
         ///   A32: VEXT.8 Dd, Dn, Dm, #n
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #n
         /// </summary>
-        public static Vector64<byte> ExtractVector64(Vector64<byte> upper, Vector64<byte> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ExtractVector64(Vector64<byte> upper, Vector64<byte> lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*2)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2)
         /// </summary>
-        public static Vector64<short> ExtractVector64(Vector64<short> upper, Vector64<short> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ExtractVector64(Vector64<short> upper, Vector64<short> lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*4)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
         /// </summary>
-        public static Vector64<int> ExtractVector64(Vector64<int> upper, Vector64<int> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ExtractVector64(Vector64<int> upper, Vector64<int> lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vext_s8 (int8x8_t a, int8x8_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #n
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ExtractVector64(Vector64<sbyte> upper, Vector64<sbyte> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ExtractVector64(Vector64<sbyte> upper, Vector64<sbyte> lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*4)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
         /// </summary>
-        public static Vector64<float> ExtractVector64(Vector64<float> upper, Vector64<float> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> ExtractVector64(Vector64<float> upper, Vector64<float> lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vext_s16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*2)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2)
         /// </summary>
-        public static Vector64<ushort> ExtractVector64(Vector64<ushort> upper, Vector64<ushort> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ExtractVector64(Vector64<ushort> upper, Vector64<ushort> lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vext_s32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*4)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
         /// </summary>
-        public static Vector64<uint> ExtractVector64(Vector64<uint> upper, Vector64<uint> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ExtractVector64(Vector64<uint> upper, Vector64<uint> lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #n
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #n
         /// </summary>
-        public static Vector128<byte> ExtractVector128(Vector128<byte> upper, Vector128<byte> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ExtractVector128(Vector128<byte> upper, Vector128<byte> lower, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*8)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
         /// </summary>
-        public static Vector128<double> ExtractVector128(Vector128<double> upper, Vector128<double> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> ExtractVector128(Vector128<double> upper, Vector128<double> lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*2)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2)
         /// </summary>
-        public static Vector128<short> ExtractVector128(Vector128<short> upper, Vector128<short> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ExtractVector128(Vector128<short> upper, Vector128<short> lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*4)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
         /// </summary>
-        public static Vector128<int> ExtractVector128(Vector128<int> upper, Vector128<int> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ExtractVector128(Vector128<int> upper, Vector128<int> lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*8)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
         /// </summary>
-        public static Vector128<long> ExtractVector128(Vector128<long> upper, Vector128<long> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ExtractVector128(Vector128<long> upper, Vector128<long> lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vextq_s8 (int8x16_t a, int8x16_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #n
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ExtractVector128(Vector128<sbyte> upper, Vector128<sbyte> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ExtractVector128(Vector128<sbyte> upper, Vector128<sbyte> lower, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*4)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
         /// </summary>
-        public static Vector128<float> ExtractVector128(Vector128<float> upper, Vector128<float> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> ExtractVector128(Vector128<float> upper, Vector128<float> lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vextq_s16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*2)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2)
         /// </summary>
-        public static Vector128<ushort> ExtractVector128(Vector128<ushort> upper, Vector128<ushort> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ExtractVector128(Vector128<ushort> upper, Vector128<ushort> lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vextq_s32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*4)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
         /// </summary>
-        public static Vector128<uint> ExtractVector128(Vector128<uint> upper, Vector128<uint> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ExtractVector128(Vector128<uint> upper, Vector128<uint> lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vextq_s64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*8)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
         /// </summary>
-        public static Vector128<ulong> ExtractVector128(Vector128<ulong> upper, Vector128<ulong> lower, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ExtractVector128(Vector128<ulong> upper, Vector128<ulong> lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vrndm_f32 (float32x2_t a)
@@ -7635,140 +7636,140 @@ internal Arm64() { }
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector64<byte> Insert(Vector64<byte> vector, byte index, byte data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> Insert(Vector64<byte> vector, [ConstantExpected(Max = (byte)(7))] byte index, byte data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector64<short> Insert(Vector64<short> vector, byte index, short data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> Insert(Vector64<short> vector, [ConstantExpected(Max = (byte)(3))] byte index, short data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector64<int> Insert(Vector64<int> vector, byte index, int data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> Insert(Vector64<int> vector, [ConstantExpected(Max = (byte)(1))] byte index, int data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane)
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector64<sbyte> Insert(Vector64<sbyte> vector, byte index, sbyte data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> Insert(Vector64<sbyte> vector, [ConstantExpected(Max = (byte)(7))] byte index, sbyte data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: INS Vd.S[lane], Vn.S[0]
         /// </summary>
-        public static Vector64<float> Insert(Vector64<float> vector, byte index, float data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> Insert(Vector64<float> vector, [ConstantExpected(Max = (byte)(1))] byte index, float data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector64<ushort> Insert(Vector64<ushort> vector, byte index, ushort data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> Insert(Vector64<ushort> vector, [ConstantExpected(Max = (byte)(3))] byte index, ushort data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector64<uint> Insert(Vector64<uint> vector, byte index, uint data) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> Insert(Vector64<uint> vector, [ConstantExpected(Max = (byte)(1))] byte index, uint data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane)
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector128<byte> Insert(Vector128<byte> vector, byte index, byte data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> Insert(Vector128<byte> vector, [ConstantExpected(Max = (byte)(15))] byte index, byte data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane)
         ///   A32: VMOV.F64 Dd, Dm
         ///   A64: INS Vd.D[lane], Vn.D[0]
         /// </summary>
-        public static Vector128<double> Insert(Vector128<double> vector, byte index, double data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Insert(Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index, double data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector128<short> Insert(Vector128<short> vector, byte index, short data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> Insert(Vector128<short> vector, [ConstantExpected(Max = (byte)(7))] byte index, short data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector128<int> Insert(Vector128<int> vector, byte index, int data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Insert(Vector128<int> vector, [ConstantExpected(Max = (byte)(3))] byte index, int data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane)
         ///   A32: VMOV.64 Dd, Rt, Rt2
         ///   A64: INS Vd.D[lane], Xn
         /// </summary>
-        public static Vector128<long> Insert(Vector128<long> vector, byte index, long data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> Insert(Vector128<long> vector, [ConstantExpected(Max = (byte)(1))] byte index, long data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane)
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, byte index, sbyte data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, [ConstantExpected(Max = (byte)(15))] byte index, sbyte data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: INS Vd.S[lane], Vn.S[0]
         /// </summary>
-        public static Vector128<float> Insert(Vector128<float> vector, byte index, float data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Insert(Vector128<float> vector, [ConstantExpected(Max = (byte)(3))] byte index, float data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector128<ushort> Insert(Vector128<ushort> vector, byte index, ushort data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> Insert(Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index, ushort data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector128<uint> Insert(Vector128<uint> vector, byte index, uint data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Insert(Vector128<uint> vector, [ConstantExpected(Max = (byte)(3))] byte index, uint data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane)
         ///   A32: VMOV.64 Dd, Rt, Rt2
         ///   A64: INS Vd.D[lane], Xn
         /// </summary>
-        public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, [ConstantExpected(Max = (byte)(1))] byte index, ulong data) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2)
         ///   A32: VMOV.F64 Dd, Dm
         ///   A64: INS Vd.D[lane1], Vn.D[0]
         /// </summary>
-        public static Vector128<double> InsertScalar(Vector128<double> result, byte resultIndex, Vector64<double> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> InsertScalar(Vector128<double> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<double> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2)
         ///   A32: VMOV Dd, Dm
         ///   A64: INS Vd.D[lane1], Vn.D[0]
         /// </summary>
-        public static Vector128<long> InsertScalar(Vector128<long> result, byte resultIndex, Vector64<long> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> InsertScalar(Vector128<long> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<long> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2)
         ///   A32: VMOV Dd, Dm
         ///   A64: INS Vd.D[lane1], Vn.D[0]
         /// </summary>
-        public static Vector128<ulong> InsertScalar(Vector128<ulong> result, byte resultIndex, Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> InsertScalar(Vector128<ulong> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vcls_s16 (int16x4_t a)
@@ -7901,119 +7902,119 @@ internal Arm64() { }
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<byte> LoadAndInsertScalar(Vector64<byte> value, byte index, byte* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<byte> LoadAndInsertScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<short> LoadAndInsertScalar(Vector64<short> value, byte index, short* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<short> LoadAndInsertScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index, short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<int> LoadAndInsertScalar(Vector64<int> value, byte index, int* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<int> LoadAndInsertScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index, int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane)
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<sbyte> LoadAndInsertScalar(Vector64<sbyte> value, byte index, sbyte* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<sbyte> LoadAndInsertScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<float> LoadAndInsertScalar(Vector64<float> value, byte index, float* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<float> LoadAndInsertScalar(Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index, float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<ushort> LoadAndInsertScalar(Vector64<ushort> value, byte index, ushort* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<ushort> LoadAndInsertScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<uint> LoadAndInsertScalar(Vector64<uint> value, byte index, uint* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector64<uint> LoadAndInsertScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane)
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<byte> LoadAndInsertScalar(Vector128<byte> value, byte index, byte* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<byte> LoadAndInsertScalar(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane)
         ///   A32: VLDR.64 Dd, [Rn]
         ///   A64: LD1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<double> LoadAndInsertScalar(Vector128<double> value, byte index, double* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<double> LoadAndInsertScalar(Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index, double* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<short> LoadAndInsertScalar(Vector128<short> value, byte index, short* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<short> LoadAndInsertScalar(Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index, short* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<int> LoadAndInsertScalar(Vector128<int> value, byte index, int* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> LoadAndInsertScalar(Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index, int* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane)
         ///   A32: VLDR.64 Dd, [Rn]
         ///   A64: LD1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<long> LoadAndInsertScalar(Vector128<long> value, byte index, long* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<long> LoadAndInsertScalar(Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte index, long* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane)
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<sbyte> LoadAndInsertScalar(Vector128<sbyte> value, byte index, sbyte* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<sbyte> LoadAndInsertScalar(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<float> LoadAndInsertScalar(Vector128<float> value, byte index, float* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> LoadAndInsertScalar(Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index, float* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<ushort> LoadAndInsertScalar(Vector128<ushort> value, byte index, ushort* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<ushort> LoadAndInsertScalar(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<uint> LoadAndInsertScalar(Vector128<uint> value, byte index, uint* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> LoadAndInsertScalar(Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane)
         ///   A32: VLDR.64 Dd, [Rn]
         ///   A64: LD1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<ulong> LoadAndInsertScalar(Vector128<ulong> value, byte index, ulong* address) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<ulong> LoadAndInsertScalar(Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr)
@@ -8846,112 +8847,112 @@ internal Arm64() { }
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b)
@@ -9028,476 +9029,476 @@ internal Arm64() { }
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane)
         ///   A32: VMUL.F32 Dd, Dn, Dm[lane]
         ///   A64: FMUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane)
         ///   A32: VMUL.F32 Dd, Dn, Dm[lane]
         ///   A64: FMUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane)
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane)
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane)
         ///   A32: VMUL.F32 Qd, Qn, Dm[lane]
         ///   A64: FMUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane)
         ///   A32: VMUL.F32 Qd, Qn, Dm[lane]
         ///   A64: FMUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqdmulh_n_s16 (int16x4_t a, int16_t b)
@@ -9532,56 +9533,56 @@ internal Arm64() { }
         ///   A32: VQDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VQDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqdmulh_s16 (int16x4_t a, int16x4_t b)
@@ -9672,56 +9673,56 @@ internal Arm64() { }
         ///   A32: VQDMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmull_s16 (int16x4_t a, int16x4_t b)
@@ -9756,28 +9757,28 @@ internal Arm64() { }
         ///   A32: VQDMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmull_high_s16 (int16x8_t a, int16x8_t b)
@@ -9812,28 +9813,28 @@ internal Arm64() { }
         ///   A32: VQDMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
@@ -9896,56 +9897,56 @@ internal Arm64() { }
         ///   A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqdmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqdmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrdmulh_n_s16 (int16x4_t a, int16_t b)
@@ -9980,56 +9981,56 @@ internal Arm64() { }
         ///   A32: VQRDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VQRDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VQRDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VQRDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VQRDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VQRDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VQRDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VQRDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrdmulh_s16 (int16x4_t a, int16x4_t b)
@@ -10079,14 +10080,14 @@ internal Arm64() { }
         ///   A32: VMUL.F32 Sd, Sn, Dm[lane]
         ///   A64: FMUL Sd, Sn, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane)
         ///   A32: VMUL.F32 Sd, Sn, Dm[lane]
         ///   A64: FMUL Sd, Sn, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c)
@@ -10233,112 +10234,112 @@ internal Arm64() { }
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b)
@@ -11847,469 +11848,469 @@ 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(63))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(31))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(63))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(31))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(127))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Qd, Qm, #n
         ///   A64: SLI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(127))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Qd, Qm, #n
         ///   A64: SLI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Max = (byte)(7))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Max = (byte)(7))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftLeftLogical(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftLeftLogical(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHL.I32 Qd, Qm, #n
         ///   A64: SHL Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHL.I64 Qd, Qm, #n
         ///   A64: SHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHL.S32 Qd, Qm, #n
         ///   A64: SQSHL Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftLogicalSaturate(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogicalSaturate(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHL.S64 Qd, Qm, #n
         ///   A64: SQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQSHL.U32 Qd, Qm, #n
         ///   A64: UQSHL Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalSaturate(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogicalSaturate(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQSHL.U64 Qd, Qm, #n
         ///   A64: UQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHLU.S32 Qd, Qm, #n
         ///   A64: SQSHLU Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalSaturateUnsigned(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogicalSaturateUnsigned(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHLU.S64 Qd, Qm, #n
         ///   A64: SQSHLU Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n)
         ///   A32: VSHLL.S32 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.2D, Vn.4S, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalWideningUpper(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogicalWideningUpper(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n)
         ///   A32: VSHLL.S8 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.8H, Vn.16B, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHLL.U32 Qd, Dm+1, #n
         ///   A64: USHLL2 Vd.2D, Vn.4S, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalWideningUpper(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogicalWideningUpper(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b)
@@ -12764,1288 +12765,1288 @@ 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Qd, Qm, #n
         ///   A64: SRI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Qd, Qm, #n
         ///   A64: SRI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Min = 1, Max = (byte)(8))] 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
         /// </summary>
-        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n)
         ///   A32: VSHR.S32 Qd, Qm, #n
         ///   A64: SSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n)
         ///   A32: VSHR.S64 Qd, Qm, #n
         ///   A64: SSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
         ///   A32: VSRA.S32 Qd, Qm, #n
         ///   A64: SSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticAdd(Vector128<int> addend, Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n)
         ///   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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n)
         ///   A32: VRSHR.S32 Qd, Qm, #n
         ///   A64: SRSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n)
         ///   A32: VRSHR.S64 Qd, Qm, #n
         ///   A64: SRSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
         ///   A32: VRSRA.S32 Qd, Qm, #n
         ///   A64: SRSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRoundedAdd(Vector128<int> addend, Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticRoundedAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n)
         ///   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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogical(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogical(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHR.U32 Qd, Qm, #n
         ///   A64: USHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHR.U32 Qd, Qm, #n
         ///   A64: USHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VSRA.U32 Qd, Qm, #n
         ///   A64: USRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalAdd(Vector128<int> addend, Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VSRA.U32 Qd, Qm, #n
         ///   A64: USRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalAdd(Vector128<uint> addend, Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalAdd(Vector128<uint> addend, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VRSHR.U32 Qd, Qm, #n
         ///   A64: URSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VRSHR.U32 Qd, Qm, #n
         ///   A64: URSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VRSRA.U32 Qd, Qm, #n
         ///   A64: URSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRoundedAdd(Vector128<int> addend, Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VRSRA.U32 Qd, Qm, #n
         ///   A64: URSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRoundedAdd(Vector128<uint> addend, Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedAdd(Vector128<uint> addend, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vmovl_s16 (int16x4_t a)
@@ -14249,119 +14250,119 @@ internal Arm64() { }
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(byte* address, Vector64<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(byte* address, Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(short* address, Vector64<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(short* address, Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(int* address, Vector64<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(int* address, Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane)
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(sbyte* address, Vector64<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(sbyte* address, Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(float* address, Vector64<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(float* address, Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ushort* address, Vector64<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(ushort* address, Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(uint* address, Vector64<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(uint* address, Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane)
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(byte* address, Vector128<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(byte* address, Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane)
         ///   A32: VSTR.64 Dd, [Rn]
         ///   A64: ST1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(double* address, Vector128<double> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(double* address, Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(short* address, Vector128<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(short* address, Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(int* address, Vector128<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(int* address, Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane)
         ///   A32: VSTR.64 Dd, [Rn]
         ///   A64: ST1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(long* address, Vector128<long> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(long* address, Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane)
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(sbyte* address, Vector128<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(sbyte* address, Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(float* address, Vector128<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(float* address, Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ushort* address, Vector128<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(ushort* address, Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(uint* address, Vector128<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(uint* address, Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane)
         ///   A32: VSTR.64 Dd, [Rn]
         ///   A64: ST1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ulong* address, Vector128<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static unsafe void StoreSelectedScalar(ulong* address, Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b)
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 6edccbd383663d..3a866329010fbd 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
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.Arm
@@ -51,25 +52,25 @@ internal AdvSimd() { }
         //     /// float32x2_t vmla_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLA.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float32x2_t vmla_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLA.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        //     public static Vector64<float> MultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float32x4_t vmlaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLA.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float32x4_t vmlaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLA.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        //     public static Vector128<float> MultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float64x1_t vmla_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
@@ -112,25 +113,25 @@ internal AdvSimd() { }
         //     /// float32x2_t vmls_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLS.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float32x2_t vmls_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLS.F32 Dd, Dn, Dm[lane]
         //     /// </summary>
-        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        //     public static Vector64<float> MultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float32x4_t vmlsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
         //     ///   A32: VMLS.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float32x4_t vmlsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
         //     ///   A32: VMLS.F32 Qd, Qn, Dm[lane]
         //     /// </summary>
-        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        //     public static Vector128<float> MultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
         //
         //     /// <summary>
         //     /// float64x1_t vmls_f64 (float64x1_t a, float64x1_t b, float64x1_t c)
@@ -1125,19 +1126,19 @@ internal Arm64() { }
             /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane)
             ///   A64: DUP Vd.2D, Vn.D[index]
             /// </summary>
-            public static Vector128<double> DuplicateSelectedScalarToVector128(Vector128<double> value, byte index) => DuplicateSelectedScalarToVector128(value, index);
+            public static Vector128<double> DuplicateSelectedScalarToVector128(Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
             /// <summary>
             /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane)
             ///   A64: DUP Vd.2D, Vn.D[index]
             /// </summary>
-            public static Vector128<long> DuplicateSelectedScalarToVector128(Vector128<long> value, byte index) => DuplicateSelectedScalarToVector128(value, index);
+            public static Vector128<long> DuplicateSelectedScalarToVector128(Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
             /// <summary>
             /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane)
             ///   A64: DUP Vd.2D, Vn.D[index]
             /// </summary>
-            public static Vector128<ulong> DuplicateSelectedScalarToVector128(Vector128<ulong> value, byte index) => DuplicateSelectedScalarToVector128(value, index);
+            public static Vector128<ulong> DuplicateSelectedScalarToVector128(Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
             /// <summary>
             /// float64x2_t vdupq_n_f64 (float64_t value)
@@ -1245,49 +1246,49 @@ internal Arm64() { }
             /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
             ///   A64: FMLA Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
             ///   A64: FMLA Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane)
             ///   A64: FMLA Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> FusedMultiplyAddBySelectedScalar(Vector128<double> addend, Vector128<double> left, Vector128<double> right, byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector128<double> FusedMultiplyAddBySelectedScalar(Vector128<double> addend, Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
             ///   A64: FMLA Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
             ///   A64: FMLA Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane)
             ///   A64: FMLA Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> FusedMultiplyAddScalarBySelectedScalar(Vector64<double> addend, Vector64<double> left, Vector128<double> right, byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector64<double> FusedMultiplyAddScalarBySelectedScalar(Vector64<double> addend, Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane)
             ///   A64: FMLA Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane)
             ///   A64: FMLA Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex);
 
             /// <summary>
             /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c)
@@ -1317,235 +1318,235 @@ internal Arm64() { }
             /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane)
             ///   A64: FMLS Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane)
             ///   A64: FMLS Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane)
             ///   A64: FMLS Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> FusedMultiplySubtractBySelectedScalar(Vector128<double> minuend, Vector128<double> left, Vector128<double> right, byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector128<double> FusedMultiplySubtractBySelectedScalar(Vector128<double> minuend, Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane)
             ///   A64: FMLS Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane)
             ///   A64: FMLS Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane)
             ///   A64: FMLS Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(Vector64<double> minuend, Vector64<double> left, Vector128<double> right, byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(Vector64<double> minuend, Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane)
             ///   A64: FMLS Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane)
             ///   A64: FMLS Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex);
+            public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex);
 
             /// <summary>
             /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, byte resultIndex, Vector64<byte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, byte resultIndex, Vector128<byte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, byte resultIndex, Vector64<short> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, byte resultIndex, Vector128<short> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<short> InsertSelectedScalar(Vector64<short> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, byte resultIndex, Vector64<int> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, byte resultIndex, Vector128<int> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<int> InsertSelectedScalar(Vector64<int> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, byte resultIndex, Vector64<sbyte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, byte resultIndex, Vector128<sbyte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, byte resultIndex, Vector64<float> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, byte resultIndex, Vector128<float> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<float> InsertSelectedScalar(Vector64<float> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, byte resultIndex, Vector64<ushort> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, byte resultIndex, Vector128<ushort> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, byte resultIndex, Vector64<uint> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, byte resultIndex, Vector128<uint> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, byte resultIndex, Vector64<byte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, byte resultIndex, Vector128<byte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2)
             ///   A64: INS Vd.D[lane1], Vn.D[lane2]
             /// </summary>
-            public static Vector128<double> InsertSelectedScalar(Vector128<double> result, byte resultIndex, Vector128<double> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<double> InsertSelectedScalar(Vector128<double> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, byte resultIndex, Vector64<short> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, byte resultIndex, Vector128<short> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<short> InsertSelectedScalar(Vector128<short> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, byte resultIndex, Vector64<int> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, byte resultIndex, Vector128<int> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<int> InsertSelectedScalar(Vector128<int> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2)
             ///   A64: INS Vd.D[lane1], Vn.D[lane2]
             /// </summary>
-            public static Vector128<long> InsertSelectedScalar(Vector128<long> result, byte resultIndex, Vector128<long> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<long> InsertSelectedScalar(Vector128<long> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, byte resultIndex, Vector64<sbyte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2)
             ///   A64: INS Vd.B[lane1], Vn.B[lane2]
             /// </summary>
-            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, byte resultIndex, Vector128<sbyte> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, byte resultIndex, Vector64<float> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, byte resultIndex, Vector128<float> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<float> InsertSelectedScalar(Vector128<float> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, byte resultIndex, Vector64<ushort> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2)
             ///   A64: INS Vd.H[lane1], Vn.H[lane2]
             /// </summary>
-            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, byte resultIndex, Vector128<ushort> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, byte resultIndex, Vector64<uint> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2)
             ///   A64: INS Vd.S[lane1], Vn.S[lane2]
             /// </summary>
-            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, byte resultIndex, Vector128<uint> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2)
             ///   A64: INS Vd.D[lane1], Vn.D[lane2]
             /// </summary>
-            public static Vector128<ulong> InsertSelectedScalar(Vector128<ulong> result, byte resultIndex, Vector128<ulong> value, byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
+            public static Vector128<ulong> InsertSelectedScalar(Vector128<ulong> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex));
 
             /// <summary>
             /// float64x2_t vld1q_dup_f64 (float64_t const * ptr)
@@ -2185,7 +2186,7 @@ internal Arm64() { }
             /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane)
             ///   A64: FMUL Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> MultiplyBySelectedScalar(Vector128<double> left, Vector128<double> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+            public static Vector128<double> MultiplyBySelectedScalar(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqdmulhh_s16 (int16_t a, int16_t b)
@@ -2203,25 +2204,25 @@ internal Arm64() { }
             /// int16_t vqdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane)
             ///   A64: SQDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane)
             ///   A64: SQDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane)
             ///   A64: SQDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane)
             ///   A64: SQDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmlalh_s16 (int32_t a, int16_t b, int16_t c)
@@ -2263,73 +2264,73 @@ internal Arm64() { }
             /// int32_t vqdmullh_lane_s16 (int16_t a, int16x4_t v, const int lane)
             ///   A64: SQDMULL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmullh_laneq_s16 (int16_t a, int16x8_t v, const int lane)
             ///   A64: SQDMULL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// int64_t vqdmulls_lane_s32 (int32_t a, int32x2_t v, const int lane)
             ///   A64: SQDMULL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// int64_t vqdmulls_laneq_s32 (int32_t a, int32x4_t v, const int lane)
             ///   A64: SQDMULL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmlalh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQDMLAL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmlalh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQDMLAL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
             /// <summary>
             /// int64_t vqdmlals_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQDMLAL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
             /// <summary>
             /// int64_t vqdmlals_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQDMLAL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmlslh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQDMLSL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqdmlslh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQDMLSL Sd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+            public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
             /// <summary>
             /// int64_t vqdmlsls_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQDMLSL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
             /// <summary>
             /// int64_t vqdmlsls_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQDMLSL Dd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+            public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
             /// <summary>
             /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b)
@@ -2359,31 +2360,31 @@ internal Arm64() { }
             /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane)
             ///   A64: FMULX Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
+            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane)
             ///   A64: FMULX Vd.2S, Vn.2S, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
+            public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane)
             ///   A64: FMULX Vd.2D, Vn.2D, Vm.D[lane]
             /// </summary>
-            public static Vector128<double> MultiplyExtendedBySelectedScalar(Vector128<double> left, Vector128<double> right, byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
+            public static Vector128<double> MultiplyExtendedBySelectedScalar(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane)
             ///   A64: FMULX Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector64<float> right, byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
+            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane)
             ///   A64: FMULX Vd.4S, Vn.4S, Vm.S[lane]
             /// </summary>
-            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector128<float> right, byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
+            public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b)
@@ -2401,19 +2402,19 @@ internal Arm64() { }
             /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane)
             ///   A64: FMULX Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> MultiplyExtendedScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<double> MultiplyExtendedScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane)
             ///   A64: FMULX Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane)
             ///   A64: FMULX Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqrdmulhh_s16 (int16_t a, int16_t b)
@@ -2431,31 +2432,31 @@ internal Arm64() { }
             /// int16_t vqrdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane)
             ///   A64: SQRDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqrdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane)
             ///   A64: SQRDMULH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqrdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane)
             ///   A64: SQRDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqrdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane)
             ///   A64: SQRDMULH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex);
 
             /// <summary>
             /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane)
             ///   A64: FMUL Dd, Dn, Vm.D[lane]
             /// </summary>
-            public static Vector64<double> MultiplyScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex);
+            public static Vector64<double> MultiplyScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex);
 
             /// <summary>
             /// float64x2_t vnegq_f64 (float64x2_t a)
@@ -2659,55 +2660,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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+            public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+            public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+            public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+            public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b)
@@ -2785,145 +2786,145 @@ internal Arm64() { }
             /// int16_t vqshrns_n_s32 (int32_t a, const int n)
             ///   A64: SQSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<int> value, byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
+            public static Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshruns_n_s32 (int32_t a, const int n)
             ///   A64: SQSHRUN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<int> value, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// int16_t vqrshrns_n_s32 (int32_t a, const int n)
             ///   A64: SQRSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<int> value, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// uint16_t vqrshruns_n_s32 (int32_t a, const int n)
             ///   A64: SQRSHRUN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<int> value, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count);
+            public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(Vector64<int> value, byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(Vector64<uint> value, byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count);
+            public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQRSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<int> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n)
             ///   A64: UQRSHRN Sd, Dn, #n
             /// </summary>
-            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n)
             ///   A64: UQRSHRN Bd, Hn, #n
             /// </summary>
-            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n)
             ///   A64: UQRSHRN Hd, Sn, #n
             /// </summary>
-            public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<uint> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
+            public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count);
 
             /// <summary>
             /// float32x2_t vsqrt_f32 (float32x2_t a)
@@ -6520,196 +6521,196 @@ internal Arm64() { }
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector64<byte> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector64<short> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector64<int> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector64<float> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane)
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector64<sbyte> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector64<ushort> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector64<uint> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane)
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector128<byte> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector128<short> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<short> DuplicateSelectedScalarToVector64(Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector128<int> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<int> DuplicateSelectedScalarToVector64(Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector128<float> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<float> DuplicateSelectedScalarToVector64(Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane)
         ///   A32: VDUP.8 Dd, Dm[index]
         ///   A64: DUP Vd.8B, Vn.B[index]
         /// </summary>
-        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector128<sbyte> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane)
         ///   A32: VDUP.16 Dd, Dm[index]
         ///   A64: DUP Vd.4H, Vn.H[index]
         /// </summary>
-        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector128<ushort> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane)
         ///   A32: VDUP.32 Dd, Dm[index]
         ///   A64: DUP Vd.2S, Vn.S[index]
         /// </summary>
-        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector128<uint> value, byte index)=> DuplicateSelectedScalarToVector64(value, index);
+        public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index);
 
         /// <summary>
         /// uint8x16_t vdupq_lane_u8 (uint8x8_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector64<byte> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// int16x8_t vdupq_lane_s16 (int16x4_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector64<short> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// int32x4_t vdupq_lane_s32 (int32x2_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector64<int> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector64<float> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// int8x16_t vdupq_lane_s8 (int8x8_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector64<sbyte> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// uint16x8_t vdupq_lane_u16 (uint16x4_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector64<ushort> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// uint32x4_t vdupq_lane_u32 (uint32x2_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector64<uint> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector128<byte> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector128<short> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<short> DuplicateSelectedScalarToVector128(Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector128<int> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<int> DuplicateSelectedScalarToVector128(Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// float32x4_t vdupq_lane_f32 (float32x4_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector128<float> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<float> DuplicateSelectedScalarToVector128(Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane)
         ///   A32: VDUP.8 Qd, Dm[index]
         ///   A64: DUP Vd.16B, Vn.B[index]
         /// </summary>
-        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector128<sbyte> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane)
         ///   A32: VDUP.16 Qd, Dm[index]
         ///   A64: DUP Vd.8H, Vn.H[index]
         /// </summary>
-        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector128<ushort> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane)
         ///   A32: VDUP.32 Qd, Dm[index]
         ///   A64: DUP Vd.4S, Vn.S[index]
         /// </summary>
-        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector128<uint> value, byte index)=> DuplicateSelectedScalarToVector128(value, index);
+        public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index);
 
         /// <summary>
         /// uint8x8_t vdup_n_u8 (uint8_t value)
@@ -6814,119 +6815,119 @@ internal Arm64() { }
         ///   A32: VMOV.U8 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.B[lane]
         /// </summary>
-        public static byte Extract(Vector64<byte> vector, byte index) => Extract(vector, index);
+        public static byte Extract(Vector64<byte> vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int16_t vget_lane_s16 (int16x4_t v, const int lane)
         ///   A32: VMOV.S16 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.H[lane]
         /// </summary>
-        public static short Extract(Vector64<short> vector, byte index) => Extract(vector, index);
+        public static short Extract(Vector64<short> vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int32_t vget_lane_s32 (int32x2_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.S[lane]
         /// </summary>
-        public static int Extract(Vector64<int> vector, byte index) => Extract(vector, index);
+        public static int Extract(Vector64<int> vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int8_t vget_lane_s8 (int8x8_t v, const int lane)
         ///   A32: VMOV.S8 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.B[lane]
         /// </summary>
-        public static sbyte Extract(Vector64<sbyte> vector, byte index) => Extract(vector, index);
+        public static sbyte Extract(Vector64<sbyte> vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// float32_t vget_lane_f32 (float32x2_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: DUP Sd, Vn.S[lane]
         /// </summary>
-        public static float Extract(Vector64<float> vector, byte index) => Extract(vector, index);
+        public static float Extract(Vector64<float> vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane)
         ///   A32: VMOV.U16 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.H[lane]
         /// </summary>
-        public static ushort Extract(Vector64<ushort> vector, byte index) => Extract(vector, index);
+        public static ushort Extract(Vector64<ushort> vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.S[lane]
         /// </summary>
-        public static uint Extract(Vector64<uint> vector, byte index) => Extract(vector, index);
+        public static uint Extract(Vector64<uint> vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane)
         ///   A32: VMOV.U8 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.B[lane]
         /// </summary>
-        public static byte Extract(Vector128<byte> vector, byte index) => Extract(vector, index);
+        public static byte Extract(Vector128<byte> vector, [ConstantExpected(Max = (byte)(15))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane)
         ///   A32: VMOV.F64 Dd, Dm
         ///   A64: DUP Dd, Vn.D[lane]
         /// </summary>
-        public static double Extract(Vector128<double> vector, byte index) => Extract(vector, index);
+        public static double Extract(Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane)
         ///   A32: VMOV.S16 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.H[lane]
         /// </summary>
-        public static short Extract(Vector128<short> vector, byte index) => Extract(vector, index);
+        public static short Extract(Vector128<short> vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.S[lane]
         /// </summary>
-        public static int Extract(Vector128<int> vector, byte index) => Extract(vector, index);
+        public static int Extract(Vector128<int> vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane)
         ///   A32: VMOV Rt, Rt2, Dm
         ///   A64: UMOV Xd, Vn.D[lane]
         /// </summary>
-        public static long Extract(Vector128<long> vector, byte index) => Extract(vector, index);
+        public static long Extract(Vector128<long> vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane)
         ///   A32: VMOV.S8 Rt, Dn[lane]
         ///   A64: SMOV Wd, Vn.B[lane]
         /// </summary>
-        public static sbyte Extract(Vector128<sbyte> vector, byte index) => Extract(vector, index);
+        public static sbyte Extract(Vector128<sbyte> vector, [ConstantExpected(Max = (byte)(15))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: DUP Sd, Vn.S[lane]
         /// </summary>
-        public static float Extract(Vector128<float> vector, byte index) => Extract(vector, index);
+        public static float Extract(Vector128<float> vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane)
         ///   A32: VMOV.U16 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.H[lane]
         /// </summary>
-        public static ushort Extract(Vector128<ushort> vector, byte index) => Extract(vector, index);
+        public static ushort Extract(Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane)
         ///   A32: VMOV.32 Rt, Dn[lane]
         ///   A64: UMOV Wd, Vn.S[lane]
         /// </summary>
-        public static uint Extract(Vector128<uint> vector, byte index) => Extract(vector, index);
+        public static uint Extract(Vector128<uint> vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane)
         ///   A32: VMOV Rt, Rt2, Dm
         ///   A64: UMOV Xd, Vn.D[lane]
         /// </summary>
-        public static ulong Extract(Vector128<ulong> vector, byte index) => Extract(vector, index);
+        public static ulong Extract(Vector128<ulong> vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index);
 
         /// <summary>
         /// uint8x8_t vmovn_u16 (uint16x8_t a)
@@ -7143,119 +7144,119 @@ internal Arm64() { }
         ///   A32: VEXT.8 Dd, Dn, Dm, #n
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #n
         /// </summary>
-        public static Vector64<byte> ExtractVector64(Vector64<byte> upper, Vector64<byte> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<byte> ExtractVector64(Vector64<byte> upper, Vector64<byte> lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*2)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2)
         /// </summary>
-        public static Vector64<short> ExtractVector64(Vector64<short> upper, Vector64<short> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<short> ExtractVector64(Vector64<short> upper, Vector64<short> lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*4)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
         /// </summary>
-        public static Vector64<int> ExtractVector64(Vector64<int> upper, Vector64<int> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<int> ExtractVector64(Vector64<int> upper, Vector64<int> lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// int8x8_t vext_s8 (int8x8_t a, int8x8_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #n
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #n
         /// </summary>
-        public static Vector64<sbyte> ExtractVector64(Vector64<sbyte> upper, Vector64<sbyte> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<sbyte> ExtractVector64(Vector64<sbyte> upper, Vector64<sbyte> lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*4)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
         /// </summary>
-        public static Vector64<float> ExtractVector64(Vector64<float> upper, Vector64<float> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<float> ExtractVector64(Vector64<float> upper, Vector64<float> lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// uint16x4_t vext_s16 (uint16x4_t a, uint16x4_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*2)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2)
         /// </summary>
-        public static Vector64<ushort> ExtractVector64(Vector64<ushort> upper, Vector64<ushort> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<ushort> ExtractVector64(Vector64<ushort> upper, Vector64<ushort> lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// uint32x2_t vext_s32 (uint32x2_t a, uint32x2_t b, const int n)
         ///   A32: VEXT.8 Dd, Dn, Dm, #(n*4)
         ///   A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4)
         /// </summary>
-        public static Vector64<uint> ExtractVector64(Vector64<uint> upper, Vector64<uint> lower, byte index) => ExtractVector64(upper, lower, index);
+        public static Vector64<uint> ExtractVector64(Vector64<uint> upper, Vector64<uint> lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector64(upper, lower, index);
 
         /// <summary>
         /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #n
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #n
         /// </summary>
-        public static Vector128<byte> ExtractVector128(Vector128<byte> upper, Vector128<byte> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<byte> ExtractVector128(Vector128<byte> upper, Vector128<byte> lower, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*8)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
         /// </summary>
-        public static Vector128<double> ExtractVector128(Vector128<double> upper, Vector128<double> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<double> ExtractVector128(Vector128<double> upper, Vector128<double> lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*2)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2)
         /// </summary>
-        public static Vector128<short> ExtractVector128(Vector128<short> upper, Vector128<short> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<short> ExtractVector128(Vector128<short> upper, Vector128<short> lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*4)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
         /// </summary>
-        public static Vector128<int> ExtractVector128(Vector128<int> upper, Vector128<int> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<int> ExtractVector128(Vector128<int> upper, Vector128<int> lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*8)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
         /// </summary>
-        public static Vector128<long> ExtractVector128(Vector128<long> upper, Vector128<long> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<long> ExtractVector128(Vector128<long> upper, Vector128<long> lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// int8x16_t vextq_s8 (int8x16_t a, int8x16_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #n
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #n
         /// </summary>
-        public static Vector128<sbyte> ExtractVector128(Vector128<sbyte> upper, Vector128<sbyte> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<sbyte> ExtractVector128(Vector128<sbyte> upper, Vector128<sbyte> lower, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*4)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
         /// </summary>
-        public static Vector128<float> ExtractVector128(Vector128<float> upper, Vector128<float> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<float> ExtractVector128(Vector128<float> upper, Vector128<float> lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// uint16x8_t vextq_s16 (uint16x8_t a, uint16x8_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*2)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2)
         /// </summary>
-        public static Vector128<ushort> ExtractVector128(Vector128<ushort> upper, Vector128<ushort> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<ushort> ExtractVector128(Vector128<ushort> upper, Vector128<ushort> lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// uint32x4_t vextq_s32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*4)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4)
         /// </summary>
-        public static Vector128<uint> ExtractVector128(Vector128<uint> upper, Vector128<uint> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<uint> ExtractVector128(Vector128<uint> upper, Vector128<uint> lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// uint64x2_t vextq_s64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   A32: VEXT.8 Qd, Qn, Qm, #(n*8)
         ///   A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8)
         /// </summary>
-        public static Vector128<ulong> ExtractVector128(Vector128<ulong> upper, Vector128<ulong> lower, byte index) => ExtractVector128(upper, lower, index);
+        public static Vector128<ulong> ExtractVector128(Vector128<ulong> upper, Vector128<ulong> lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector128(upper, lower, index);
 
         /// <summary>
         /// float32x2_t vrndm_f32 (float32x2_t a)
@@ -7633,140 +7634,140 @@ internal Arm64() { }
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector64<byte> Insert(Vector64<byte> vector, byte index, byte data) => Insert(vector, index, data);
+        public static Vector64<byte> Insert(Vector64<byte> vector, [ConstantExpected(Max = (byte)(7))] byte index, byte data) => Insert(vector, index, data);
 
         /// <summary>
         /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector64<short> Insert(Vector64<short> vector, byte index, short data) => Insert(vector, index, data);
+        public static Vector64<short> Insert(Vector64<short> vector, [ConstantExpected(Max = (byte)(3))] byte index, short data) => Insert(vector, index, data);
 
         /// <summary>
         /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector64<int> Insert(Vector64<int> vector, byte index, int data) => Insert(vector, index, data);
+        public static Vector64<int> Insert(Vector64<int> vector, [ConstantExpected(Max = (byte)(1))] byte index, int data) => Insert(vector, index, data);
 
         /// <summary>
         /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane)
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector64<sbyte> Insert(Vector64<sbyte> vector, byte index, sbyte data) => Insert(vector, index, data);
+        public static Vector64<sbyte> Insert(Vector64<sbyte> vector, [ConstantExpected(Max = (byte)(7))] byte index, sbyte data) => Insert(vector, index, data);
 
         /// <summary>
         /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: INS Vd.S[lane], Vn.S[0]
         /// </summary>
-        public static Vector64<float> Insert(Vector64<float> vector, byte index, float data) => Insert(vector, index, data);
+        public static Vector64<float> Insert(Vector64<float> vector, [ConstantExpected(Max = (byte)(1))] byte index, float data) => Insert(vector, index, data);
 
         /// <summary>
         /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector64<ushort> Insert(Vector64<ushort> vector, byte index, ushort data) => Insert(vector, index, data);
+        public static Vector64<ushort> Insert(Vector64<ushort> vector, [ConstantExpected(Max = (byte)(3))] byte index, ushort data) => Insert(vector, index, data);
 
         /// <summary>
         /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector64<uint> Insert(Vector64<uint> vector, byte index, uint data) => Insert(vector, index, data);
+        public static Vector64<uint> Insert(Vector64<uint> vector, [ConstantExpected(Max = (byte)(1))] byte index, uint data) => Insert(vector, index, data);
 
         /// <summary>
         /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane)
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector128<byte> Insert(Vector128<byte> vector, byte index, byte data) => Insert(vector, index, data);
+        public static Vector128<byte> Insert(Vector128<byte> vector, [ConstantExpected(Max = (byte)(15))] byte index, byte data) => Insert(vector, index, data);
 
         /// <summary>
         /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane)
         ///   A32: VMOV.F64 Dd, Dm
         ///   A64: INS Vd.D[lane], Vn.D[0]
         /// </summary>
-        public static Vector128<double> Insert(Vector128<double> vector, byte index, double data) => Insert(vector, index, data);
+        public static Vector128<double> Insert(Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte index, double data) => Insert(vector, index, data);
 
         /// <summary>
         /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector128<short> Insert(Vector128<short> vector, byte index, short data) => Insert(vector, index, data);
+        public static Vector128<short> Insert(Vector128<short> vector, [ConstantExpected(Max = (byte)(7))] byte index, short data) => Insert(vector, index, data);
 
         /// <summary>
         /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector128<int> Insert(Vector128<int> vector, byte index, int data) => Insert(vector, index, data);
+        public static Vector128<int> Insert(Vector128<int> vector, [ConstantExpected(Max = (byte)(3))] byte index, int data) => Insert(vector, index, data);
 
         /// <summary>
         /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane)
         ///   A32: VMOV.64 Dd, Rt, Rt2
         ///   A64: INS Vd.D[lane], Xn
         /// </summary>
-        public static Vector128<long> Insert(Vector128<long> vector, byte index, long data) => Insert(vector, index, data);
+        public static Vector128<long> Insert(Vector128<long> vector, [ConstantExpected(Max = (byte)(1))] byte index, long data) => Insert(vector, index, data);
 
         /// <summary>
         /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane)
         ///   A32: VMOV.8 Dd[lane], Rt
         ///   A64: INS Vd.B[lane], Wn
         /// </summary>
-        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, byte index, sbyte data) => Insert(vector, index, data);
+        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, [ConstantExpected(Max = (byte)(15))] byte index, sbyte data) => Insert(vector, index, data);
 
         /// <summary>
         /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane)
         ///   A32: VMOV.F32 Sd, Sm
         ///   A64: INS Vd.S[lane], Vn.S[0]
         /// </summary>
-        public static Vector128<float> Insert(Vector128<float> vector, byte index, float data) => Insert(vector, index, data);
+        public static Vector128<float> Insert(Vector128<float> vector, [ConstantExpected(Max = (byte)(3))] byte index, float data) => Insert(vector, index, data);
 
         /// <summary>
         /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane)
         ///   A32: VMOV.16 Dd[lane], Rt
         ///   A64: INS Vd.H[lane], Wn
         /// </summary>
-        public static Vector128<ushort> Insert(Vector128<ushort> vector, byte index, ushort data) => Insert(vector, index, data);
+        public static Vector128<ushort> Insert(Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte index, ushort data) => Insert(vector, index, data);
 
         /// <summary>
         /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane)
         ///   A32: VMOV.32 Dd[lane], Rt
         ///   A64: INS Vd.S[lane], Wn
         /// </summary>
-        public static Vector128<uint> Insert(Vector128<uint> vector, byte index, uint data) => Insert(vector, index, data);
+        public static Vector128<uint> Insert(Vector128<uint> vector, [ConstantExpected(Max = (byte)(3))] byte index, uint data) => Insert(vector, index, data);
 
         /// <summary>
         /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane)
         ///   A32: VMOV.64 Dd, Rt, Rt2
         ///   A64: INS Vd.D[lane], Xn
         /// </summary>
-        public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data) => Insert(vector, index, data);
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, [ConstantExpected(Max = (byte)(1))] byte index, ulong data) => Insert(vector, index, data);
 
         /// <summary>
         /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2)
         ///   A32: VMOV.F64 Dd, Dm
         ///   A64: INS Vd.D[lane1], Vn.D[0]
         /// </summary>
-        public static Vector128<double> InsertScalar(Vector128<double> result, byte resultIndex, Vector64<double> value) => InsertScalar(result, resultIndex, value);
+        public static Vector128<double> InsertScalar(Vector128<double> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<double> value) => InsertScalar(result, resultIndex, value);
 
         /// <summary>
         /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2)
         ///   A32: VMOV Dd, Dm
         ///   A64: INS Vd.D[lane1], Vn.D[0]
         /// </summary>
-        public static Vector128<long> InsertScalar(Vector128<long> result, byte resultIndex, Vector64<long> value) => InsertScalar(result, resultIndex, value);
+        public static Vector128<long> InsertScalar(Vector128<long> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<long> value) => InsertScalar(result, resultIndex, value);
 
         /// <summary>
         /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2)
         ///   A32: VMOV Dd, Dm
         ///   A64: INS Vd.D[lane1], Vn.D[0]
         /// </summary>
-        public static Vector128<ulong> InsertScalar(Vector128<ulong> result, byte resultIndex, Vector64<ulong> value) => InsertScalar(result, resultIndex, value);
+        public static Vector128<ulong> InsertScalar(Vector128<ulong> result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64<ulong> value) => InsertScalar(result, resultIndex, value);
 
         /// <summary>
         /// int16x4_t vcls_s16 (int16x4_t a)
@@ -7899,119 +7900,119 @@ internal Arm64() { }
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<byte> LoadAndInsertScalar(Vector64<byte> value, byte index, byte* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<byte> LoadAndInsertScalar(Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<short> LoadAndInsertScalar(Vector64<short> value, byte index, short* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<short> LoadAndInsertScalar(Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index, short* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<int> LoadAndInsertScalar(Vector64<int> value, byte index, int* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<int> LoadAndInsertScalar(Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index, int* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane)
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<sbyte> LoadAndInsertScalar(Vector64<sbyte> value, byte index, sbyte* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<sbyte> LoadAndInsertScalar(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<float> LoadAndInsertScalar(Vector64<float> value, byte index, float* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<float> LoadAndInsertScalar(Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index, float* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<ushort> LoadAndInsertScalar(Vector64<ushort> value, byte index, ushort* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<ushort> LoadAndInsertScalar(Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector64<uint> LoadAndInsertScalar(Vector64<uint> value, byte index, uint* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector64<uint> LoadAndInsertScalar(Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane)
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<byte> LoadAndInsertScalar(Vector128<byte> value, byte index, byte* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<byte> LoadAndInsertScalar(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane)
         ///   A32: VLDR.64 Dd, [Rn]
         ///   A64: LD1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<double> LoadAndInsertScalar(Vector128<double> value, byte index, double* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<double> LoadAndInsertScalar(Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index, double* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<short> LoadAndInsertScalar(Vector128<short> value, byte index, short* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<short> LoadAndInsertScalar(Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index, short* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<int> LoadAndInsertScalar(Vector128<int> value, byte index, int* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<int> LoadAndInsertScalar(Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index, int* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane)
         ///   A32: VLDR.64 Dd, [Rn]
         ///   A64: LD1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<long> LoadAndInsertScalar(Vector128<long> value, byte index, long* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<long> LoadAndInsertScalar(Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte index, long* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane)
         ///   A32: VLD1.8 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<sbyte> LoadAndInsertScalar(Vector128<sbyte> value, byte index, sbyte* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<sbyte> LoadAndInsertScalar(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<float> LoadAndInsertScalar(Vector128<float> value, byte index, float* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<float> LoadAndInsertScalar(Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index, float* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane)
         ///   A32: VLD1.16 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<ushort> LoadAndInsertScalar(Vector128<ushort> value, byte index, ushort* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<ushort> LoadAndInsertScalar(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane)
         ///   A32: VLD1.32 { Dd[index] }, [Rn]
         ///   A64: LD1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<uint> LoadAndInsertScalar(Vector128<uint> value, byte index, uint* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<uint> LoadAndInsertScalar(Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane)
         ///   A32: VLDR.64 Dd, [Rn]
         ///   A64: LD1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe Vector128<ulong> LoadAndInsertScalar(Vector128<ulong> value, byte index, ulong* address) => LoadAndInsertScalar(value, index, address);
+        public static unsafe Vector128<ulong> LoadAndInsertScalar(Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) => LoadAndInsertScalar(value, index, address);
 
         /// <summary>
         /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr)
@@ -8844,112 +8845,112 @@ internal Arm64() { }
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLA.I16 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLA.I32 Dd, Dn, Dm[lane]
         ///   A64: MLA Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLA.I16 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLA.I32 Qd, Qn, Dm[lane]
         ///   A64: MLA Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b)
@@ -9026,476 +9027,476 @@ internal Arm64() { }
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane)
         ///   A32: VMUL.F32 Dd, Dn, Dm[lane]
         ///   A64: FMUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane)
         ///   A32: VMUL.F32 Dd, Dn, Dm[lane]
         ///   A64: FMUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane)
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane)
         ///   A32: VMUL.I16 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane)
         ///   A32: VMUL.I32 Dd, Dn, Dm[lane]
         ///   A64: MUL Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane)
         ///   A32: VMUL.F32 Qd, Qn, Dm[lane]
         ///   A64: FMUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector64<float> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane)
         ///   A32: VMUL.F32 Qd, Qn, Dm[lane]
         ///   A64: FMUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector128<float> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane)
         ///   A32: VMUL.I16 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane)
         ///   A32: VMUL.I32 Qd, Qn, Dm[lane]
         ///   A64: MUL Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn, Dm[lane]
         ///   A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane)
         ///   A32: VMULL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane)
         ///   A32: VMULL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLAL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLAL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLSL.U16 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLSL.U32 Qd, Dn+1, Dm[lane]
         ///   A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
+        public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqdmulh_n_s16 (int16x4_t a, int16_t b)
@@ -9530,56 +9531,56 @@ internal Arm64() { }
         ///   A32: VQDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VQDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqdmulh_s16 (int16x4_t a, int16x4_t b)
@@ -9670,56 +9671,56 @@ internal Arm64() { }
         ///   A32: VQDMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLAL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmull_s16 (int16x4_t a, int16x4_t b)
@@ -9754,28 +9755,28 @@ internal Arm64() { }
         ///   A32: VQDMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULL.S16 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn, Dm[lane]
         ///   A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmull_high_s16 (int16x8_t a, int16x8_t b)
@@ -9810,28 +9811,28 @@ internal Arm64() { }
         ///   A32: VQDMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VQDMULL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VQDMULL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c)
@@ -9894,56 +9895,56 @@ internal Arm64() { }
         ///   A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqdmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int64x2_t vqdmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane]
         ///   A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
+        public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqrdmulh_n_s16 (int16x4_t a, int16_t b)
@@ -9978,56 +9979,56 @@ internal Arm64() { }
         ///   A32: VQRDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqrdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane)
         ///   A32: VQRDMULH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqrdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane)
         ///   A32: VQRDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqrdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane)
         ///   A32: VQRDMULH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqrdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane)
         ///   A32: VQRDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqrdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane)
         ///   A32: VQRDMULH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqrdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane)
         ///   A32: VQRDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqrdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane)
         ///   A32: VQRDMULH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqrdmulh_s16 (int16x4_t a, int16x4_t b)
@@ -10077,14 +10078,14 @@ internal Arm64() { }
         ///   A32: VMUL.F32 Sd, Sn, Dm[lane]
         ///   A64: FMUL Sd, Sn, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex);
+        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane)
         ///   A32: VMUL.F32 Sd, Sn, Dm[lane]
         ///   A64: FMUL Sd, Sn, Vm.S[lane]
         /// </summary>
-        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex);
+        public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex);
 
         /// <summary>
         /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c)
@@ -10231,112 +10232,112 @@ internal Arm64() { }
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane)
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane)
         ///   A32: VMLS.I16 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane)
         ///   A32: VMLS.I32 Dd, Dn, Dm[lane]
         ///   A64: MLS Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector128<uint> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane)
         ///   A32: VMLS.I16 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector64<uint> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane)
         ///   A32: VMLS.I32 Qd, Qn, Dm[lane]
         ///   A64: MLS Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right, byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
+        public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex);
 
         /// <summary>
         /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b)
@@ -11845,469 +11846,469 @@ 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(63))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(31))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(63))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Max = (byte)(31))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(127))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Qd, Qm, #n
         ///   A64: SLI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(127))] 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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
         ///   A32: VSLI.32 Qd, Qm, #n
         ///   A64: SLI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift);
 
         /// <summary>
         /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) => ShiftLeftAndInsert(left, right, shift);
+        public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(15))] 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, byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
+        public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Max = (byte)(7))] 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, byte shift) => ShiftLeftAndInsertScalar(left, right, shift);
+        public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Max = (byte)(7))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<short> ShiftLeftLogical(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<int> ShiftLeftLogical(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHL.I32 Qd, Qm, #n
         ///   A64: SHL Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHL.I64 Qd, Qm, #n
         ///   A64: SHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHL.S32 Qd, Qm, #n
         ///   A64: SQSHL Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftLeftLogicalSaturate(Vector128<int> value, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<int> ShiftLeftLogicalSaturate(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHL.S64 Qd, Qm, #n
         ///   A64: SQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VQSHL.U32 Qd, Qm, #n
         ///   A64: UQSHL Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalSaturate(Vector128<uint> value, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<uint> ShiftLeftLogicalSaturate(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count);
 
         /// <summary>
         /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VQSHL.U64 Qd, Qm, #n
         ///   A64: UQSHL Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, byte count) => ShiftLeftLogicalSaturate(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+        public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) => ShiftLeftLogicalSaturateScalar(value, count);
+        public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n)
         ///   A32: VQSHLU.S32 Qd, Qm, #n
         ///   A64: SQSHLU Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogicalSaturateUnsigned(Vector128<int> value, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<uint> ShiftLeftLogicalSaturateUnsigned(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
 
         /// <summary>
         /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n)
         ///   A32: VQSHLU.S64 Qd, Qm, #n
         ///   A64: SQSHLU Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalSaturateUnsigned(value, count);
+        public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count);
+        public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) => ShiftLeftLogicalScalar(value, count);
+        public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) => ShiftLeftLogicalScalar(value, count);
+        public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, [ConstantExpected(Max = (byte)(7))] 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, byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, [ConstantExpected(Max = (byte)(63))] 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, byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, [ConstantExpected(Max = (byte)(31))] 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, byte count) => ShiftLeftLogicalWideningLower(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, [ConstantExpected(Max = (byte)(15))] 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, byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n)
         ///   A32: VSHLL.S32 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.2D, Vn.4S, #n
         /// </summary>
-        public static Vector128<long> ShiftLeftLogicalWideningUpper(Vector128<int> value, byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<long> ShiftLeftLogicalWideningUpper(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n)
         ///   A32: VSHLL.S8 Qd, Dm+1, #n
         ///   A64: SSHLL2 Vd.8H, Vn.16B, #n
         /// </summary>
-        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(127))] 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, byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHLL.U32 Qd, Dm+1, #n
         ///   A64: USHLL2 Vd.2D, Vn.4S, #n
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogicalWideningUpper(Vector128<uint> value, byte count) => ShiftLeftLogicalWideningUpper(value, count);
+        public static Vector128<ulong> ShiftLeftLogicalWideningUpper(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningUpper(value, count);
 
         /// <summary>
         /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b)
@@ -12762,1288 +12763,1288 @@ 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Qd, Qm, #n
         ///   A64: SRI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n))
         ///   A32: VSRI.32 Qd, Qm, #n
         ///   A64: SRI Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift);
 
         /// <summary>
         /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n))
         ///   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, byte shift) => ShiftRightAndInsert(left, right, shift);
+        public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte shift) => ShiftRightAndInsertScalar(left, right, shift);
+        public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte shift) => ShiftRightAndInsertScalar(left, right, shift);
+        public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n)
         ///   A32: VSHR.S32 Qd, Qm, #n
         ///   A64: SSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n)
         ///   A32: VSHR.S64 Qd, Qm, #n
         ///   A64: SSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
         ///   A32: VSRA.S32 Qd, Qm, #n
         ///   A64: SSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticAdd(Vector128<int> addend, Vector128<int> value, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<int> ShiftRightArithmeticAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticAdd(addend, value, count);
 
         /// <summary>
         /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n)
         ///   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, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightArithmeticAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n)
         ///   A32: VRSHR.S32 Qd, Qm, #n
         ///   A64: SRSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRounded(value, count);
 
         /// <summary>
         /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n)
         ///   A32: VRSHR.S64 Qd, Qm, #n
         ///   A64: SRSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRounded(value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n)
         ///   A32: VRSRA.S32 Qd, Qm, #n
         ///   A64: SRSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightArithmeticRoundedAdd(Vector128<int> addend, Vector128<int> value, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<int> ShiftRightArithmeticRoundedAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
 
         /// <summary>
         /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n)
         ///   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, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightArithmeticRoundedAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count);
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightArithmeticRoundedScalar(value, count);
+        public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightArithmeticScalar(value, count);
+        public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector64<short> ShiftRightLogical(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector64<int> ShiftRightLogical(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHR.U32 Qd, Qm, #n
         ///   A64: USHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VSHR.U32 Qd, Qm, #n
         ///   A64: USHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VSHR.U64 Qd, Qm, #n
         ///   A64: USHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VSRA.U32 Qd, Qm, #n
         ///   A64: USRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalAdd(Vector128<int> addend, Vector128<int> value, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<int> ShiftRightLogicalAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VSRA.U32 Qd, Qm, #n
         ///   A64: USRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalAdd(Vector128<uint> addend, Vector128<uint> value, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<uint> ShiftRightLogicalAdd(Vector128<uint> addend, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count);
 
         /// <summary>
         /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) => ShiftRightLogicalAdd(addend, value, count);
+        public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalAddScalar(addend, value, count);
+        public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VRSHR.U32 Qd, Qm, #n
         ///   A64: URSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n)
         ///   A32: VRSHR.U32 Qd, Qm, #n
         ///   A64: URSHR Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count);
 
         /// <summary>
         /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n)
         ///   A32: VRSHR.U64 Qd, Qm, #n
         ///   A64: URSHR Vd.2D, Vn.2D, #n
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count) => ShiftRightLogicalRounded(value, count);
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VRSRA.U32 Qd, Qm, #n
         ///   A64: URSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<int> ShiftRightLogicalRoundedAdd(Vector128<int> addend, Vector128<int> value, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<int> ShiftRightLogicalRoundedAdd(Vector128<int> addend, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, [ConstantExpected(Min = 1, Max = (byte)(128))] 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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n)
         ///   A32: VRSRA.U32 Qd, Qm, #n
         ///   A64: URSRA Vd.4S, Vn.4S, #n
         /// </summary>
-        public static Vector128<uint> ShiftRightLogicalRoundedAdd(Vector128<uint> addend, Vector128<uint> value, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<uint> ShiftRightLogicalRoundedAdd(Vector128<uint> addend, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
 
         /// <summary>
         /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n)
         ///   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, byte count) => ShiftRightLogicalRoundedAdd(addend, value, count);
+        public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count);
+        public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count);
+        public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(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<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count);
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, 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<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, [ConstantExpected(Min = 1, Max = (byte)(64))] 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, byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, [ConstantExpected(Min = 1, Max = (byte)(32))] 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, byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count);
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(16))] 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, byte count) => ShiftRightLogicalRoundedScalar(value, count);
+        public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalRoundedScalar(value, count);
+        public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalScalar(value, count);
+        public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, [ConstantExpected(Min = 1, Max = (byte)(8))] 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, byte count) => ShiftRightLogicalScalar(value, count);
+        public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalScalar(value, count);
 
         /// <summary>
         /// int32x4_t vmovl_s16 (int16x4_t a)
@@ -14247,119 +14248,119 @@ internal Arm64() { }
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(byte* address, Vector64<byte> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(byte* address, Vector64<byte> value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(short* address, Vector64<short> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(short* address, Vector64<short> value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(int* address, Vector64<int> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(int* address, Vector64<int> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane)
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(sbyte* address, Vector64<sbyte> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(sbyte* address, Vector64<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(float* address, Vector64<float> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(float* address, Vector64<float> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ushort* address, Vector64<ushort> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(ushort* address, Vector64<ushort> value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(uint* address, Vector64<uint> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(uint* address, Vector64<uint> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane)
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(byte* address, Vector128<byte> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(byte* address, Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane)
         ///   A32: VSTR.64 Dd, [Rn]
         ///   A64: ST1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(double* address, Vector128<double> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(double* address, Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(short* address, Vector128<short> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(short* address, Vector128<short> value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(int* address, Vector128<int> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(int* address, Vector128<int> value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane)
         ///   A32: VSTR.64 Dd, [Rn]
         ///   A64: ST1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(long* address, Vector128<long> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(long* address, Vector128<long> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane)
         ///   A32: VST1.8 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.B }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(sbyte* address, Vector128<sbyte> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(sbyte* address, Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(float* address, Vector128<float> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(float* address, Vector128<float> value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane)
         ///   A32: VST1.16 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.H }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ushort* address, Vector128<ushort> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(ushort* address, Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane)
         ///   A32: VST1.32 { Dd[index] }, [Rn]
         ///   A64: ST1 { Vt.S }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(uint* address, Vector128<uint> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(uint* address, Vector128<uint> value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane)
         ///   A32: VSTR.64 Dd, [Rn]
         ///   A64: ST1 { Vt.D }[index], [Xn]
         /// </summary>
-        public static unsafe void StoreSelectedScalar(ulong* address, Vector128<ulong> value, byte index) => StoreSelectedScalar(address, value, index);
+        public static unsafe void StoreSelectedScalar(ulong* address, Vector128<ulong> value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index);
 
         /// <summary>
         /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs
index ba98097e7b0a8a..5f1adc320d7b73 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #pragma warning disable IDE0060 // unused parameters
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.Arm
@@ -56,55 +57,55 @@ internal Arm64() { }
         ///   A32: VSDOT.S8 Dd, Dn, Dm[lane]
         ///   A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector64<sbyte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vdot_laneq_s32 (int32x2_t r, int8x8_t a, int8x16_t b, const int lane)
         ///   A32: VSDOT.S8 Dd, Dn, Dm[lane]
         ///   A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector128<sbyte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vdot_lane_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b, const int lane)
         ///   A32: VUDOT.U8 Dd, Dn, Dm[lane]
         ///   A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector64<byte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x2_t vdot_laneq_u32 (uint32x2_t r, uint8x8_t a, uint8x16_t b, const int lane)
         ///   A32: VUDOT.U8 Dd, Dn, Dm[lane]
         ///   A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector128<byte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vdotq_laneq_s32 (int32x4_t r, int8x16_t a, int8x16_t b, const int lane)
         ///   A32: VSDOT.S8 Qd, Qn, Dm[lane]
         ///   A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector128<sbyte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vdotq_lane_s32 (int32x4_t r, int8x16_t a, int8x8_t b, const int lane)
         ///   A32: VSDOT.S8 Qd, Qn, Dm[lane]
         ///   A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector64<sbyte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vdotq_laneq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b, const int lane)
         ///   A32: VUDOT.U8 Qd, Qn, Dm[lane]
         ///   A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector128<byte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// uint32x4_t vdotq_lane_u32 (uint32x4_t r, uint8x16_t a, uint8x8_t b, const int lane)
         ///   A32: VUDOT.U8 Qd, Qn, Dm[lane]
         ///   A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector64<byte> right, byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs
index 0358b7693b1b89..8732f856925d5e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.Arm
@@ -57,55 +58,55 @@ internal Arm64() { }
         ///   A32: VSDOT.S8 Dd, Dn, Dm[lane]
         ///   A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector64<sbyte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// int32x2_t vdot_laneq_s32 (int32x2_t r, int8x8_t a, int8x16_t b, const int lane)
         ///   A32: VSDOT.S8 Dd, Dn, Dm[lane]
         ///   A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector128<sbyte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// uint32x2_t vdot_lane_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b, const int lane)
         ///   A32: VUDOT.U8 Dd, Dn, Dm[lane]
         ///   A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector64<byte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// uint32x2_t vdot_laneq_u32 (uint32x2_t r, uint8x8_t a, uint8x16_t b, const int lane)
         ///   A32: VUDOT.U8 Dd, Dn, Dm[lane]
         ///   A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane]
         /// </summary>
-        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector128<byte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// int32x4_t vdotq_laneq_s32 (int32x4_t r, int8x16_t a, int8x16_t b, const int lane)
         ///   A32: VSDOT.S8 Qd, Qn, Dm[lane]
         ///   A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector128<sbyte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// int32x4_t vdotq_lane_s32 (int32x4_t r, int8x16_t a, int8x8_t b, const int lane)
         ///   A32: VSDOT.S8 Qd, Qn, Dm[lane]
         ///   A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector64<sbyte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector64<sbyte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// uint32x4_t vdotq_laneq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b, const int lane)
         ///   A32: VUDOT.U8 Qd, Qn, Dm[lane]
         ///   A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector128<byte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector128<byte> right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
 
         /// <summary>
         /// uint32x4_t vdotq_lane_u32 (uint32x4_t r, uint8x16_t a, uint8x8_t b, const int lane)
         ///   A32: VUDOT.U8 Qd, Qn, Dm[lane]
         ///   A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane]
         /// </summary>
-        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector64<byte> right, byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
+        public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector64<byte> right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs
index 114fbf86903ce3..9fa363b883fa7e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #pragma warning disable IDE0060 // unused parameters
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.Arm
@@ -50,49 +51,49 @@ internal Arm64() { }
             /// int16_t vqrdmlahh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQRDMLAH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrdmlahh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQRDMLAH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqrdmlahs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQRDMLAH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqrdmlahs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQRDMLAH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrdmlshh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQRDMLSH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int16_t vqrdmlshh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQRDMLSH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqrdmlshs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQRDMLSH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// int32_t vqrdmlshs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQRDMLSH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
         }
 
         /// <summary>
@@ -156,111 +157,111 @@ internal Arm64() { }
         ///   A32: VQRDMLAH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrdmlah_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLAH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrdmlah_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrdmlah_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrdmlahq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VQRDMLAH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrdmlahq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLAH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrdmlahq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrdmlahq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrdmlsh_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x4_t vqrdmlsh_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrdmlsh_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x2_t vqrdmlsh_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrdmlshq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int16x8_t vqrdmlshq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrdmlshq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int32x4_t vqrdmlshq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs
index 0d1203e5b6030a..200aaa9bcf2fa9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.Arm
@@ -51,49 +52,49 @@ internal Arm64() { }
             /// int16_t vqrdmlahh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQRDMLAH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqrdmlahh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQRDMLAH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqrdmlahs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQRDMLAH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqrdmlahs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQRDMLAH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqrdmlshh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane)
             ///   A64: SQRDMLSH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
             /// <summary>
             /// int16_t vqrdmlshh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane)
             ///   A64: SQRDMLSH Hd, Hn, Vm.H[lane]
             /// </summary>
-            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+            public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqrdmlshs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane)
             ///   A64: SQRDMLSH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
             /// <summary>
             /// int32_t vqrdmlshs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane)
             ///   A64: SQRDMLSH Sd, Sn, Vm.S[lane]
             /// </summary>
-            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+            public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
         }
 
         /// <summary>
@@ -157,111 +158,111 @@ internal Arm64() { }
         ///   A32: VQRDMLAH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqrdmlah_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLAH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqrdmlah_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqrdmlah_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqrdmlahq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VQRDMLAH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqrdmlahq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLAH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqrdmlahq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqrdmlahq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLAH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqrdmlsh_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x4_t vqrdmlsh_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane]
         /// </summary>
-        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqrdmlsh_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x2_t vqrdmlsh_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Dd, Dn, Dm[lane]
         ///   A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane]
         /// </summary>
-        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqrdmlshq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int16x8_t vqrdmlshq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane)
         ///   A32: VQRDMLSH.S16 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane]
         /// </summary>
-        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqrdmlshq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
 
         /// <summary>
         /// int32x4_t vqrdmlshq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane)
         ///   A32: VQRDMLSH.S32 Qd, Qn, Dm[lane]
         ///   A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane]
         /// </summary>
-        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
+        public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs
index 644956f2deb507..2720f30f654264 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 #pragma warning disable IDE0060
@@ -25,31 +26,31 @@ public abstract class PackedSimd
         public static Vector128<nint>   Splat(nint   value) { throw new PlatformNotSupportedException(); }
         public static Vector128<nuint>  Splat(nuint  value) { throw new PlatformNotSupportedException(); }
 
-        public static int    ExtractLane(Vector128<sbyte>  value, byte index) { throw new PlatformNotSupportedException(); }
-        public static uint   ExtractLane(Vector128<byte>   value, byte index) { throw new PlatformNotSupportedException(); }
-        public static int    ExtractLane(Vector128<short>  value, byte index) { throw new PlatformNotSupportedException(); }
-        public static uint   ExtractLane(Vector128<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
-        public static int    ExtractLane(Vector128<int>    value, byte index) { throw new PlatformNotSupportedException(); }
-        public static uint   ExtractLane(Vector128<uint>   value, byte index) { throw new PlatformNotSupportedException(); }
-        public static long   ExtractLane(Vector128<long>   value, byte index) { throw new PlatformNotSupportedException(); }
-        public static ulong  ExtractLane(Vector128<ulong>  value, byte index) { throw new PlatformNotSupportedException(); }
-        public static float  ExtractLane(Vector128<float>  value, byte index) { throw new PlatformNotSupportedException(); }
-        public static double ExtractLane(Vector128<double> value, byte index) { throw new PlatformNotSupportedException(); }
-        public static nint   ExtractLane(Vector128<nint>   value, byte index) { throw new PlatformNotSupportedException(); }
-        public static nuint  ExtractLane(Vector128<nuint>  value, byte index) { throw new PlatformNotSupportedException(); }
-
-        public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, byte imm, int    value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, byte imm, uint   value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<short>  ReplaceLane(Vector128<short>  vector, byte imm, int    value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, byte imm, uint   value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int>    ReplaceLane(Vector128<int>    vector, byte imm, int    value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, byte imm, uint   value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<long>   ReplaceLane(Vector128<long>   vector, byte imm, long   value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, byte imm, ulong  value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<float>  ReplaceLane(Vector128<float>  vector, byte imm, float  value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<double> ReplaceLane(Vector128<double> vector, byte imm, double value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, byte imm, nint   value) { throw new PlatformNotSupportedException(); }
-        public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, byte imm, nuint  value) { throw new PlatformNotSupportedException(); }
+        public static int    ExtractLane(Vector128<sbyte>  value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
+        public static uint   ExtractLane(Vector128<byte>   value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); }
+        public static int    ExtractLane(Vector128<short>  value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
+        public static uint   ExtractLane(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); }
+        public static int    ExtractLane(Vector128<int>    value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
+        public static uint   ExtractLane(Vector128<uint>   value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
+        public static long   ExtractLane(Vector128<long>   value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
+        public static ulong  ExtractLane(Vector128<ulong>  value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
+        public static float  ExtractLane(Vector128<float>  value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
+        public static double ExtractLane(Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); }
+        public static nint   ExtractLane(Vector128<nint>   value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
+        public static nuint  ExtractLane(Vector128<nuint>  value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); }
+
+        public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, [ConstantExpected(Max = (byte)(15))] byte imm, int    value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, [ConstantExpected(Max = (byte)(15))] byte imm, uint   value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short>  ReplaceLane(Vector128<short>  vector, [ConstantExpected(Max = (byte)(7))] byte imm, int    value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte imm, uint   value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int>    ReplaceLane(Vector128<int>    vector, [ConstantExpected(Max = (byte)(3))] byte imm, int    value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, [ConstantExpected(Max = (byte)(3))] byte imm, uint   value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long>   ReplaceLane(Vector128<long>   vector, [ConstantExpected(Max = (byte)(1))] byte imm, long   value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, [ConstantExpected(Max = (byte)(1))] byte imm, ulong  value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float>  ReplaceLane(Vector128<float>  vector, [ConstantExpected(Max = (byte)(3))] byte imm, float  value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> ReplaceLane(Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte imm, double value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, [ConstantExpected(Max = (byte)(3))] byte imm, nint   value) { throw new PlatformNotSupportedException(); }
+        public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, [ConstantExpected(Max = (byte)(3))] byte imm, nuint  value) { throw new PlatformNotSupportedException(); }
 
         public static Vector128<sbyte> Shuffle(Vector128<sbyte> lower, Vector128<sbyte> upper, Vector128<sbyte> indices) { throw new PlatformNotSupportedException(); }
         public static Vector128<byte>  Shuffle(Vector128<byte>  lower, Vector128<byte>  upper, Vector128<byte>  indices) { throw new PlatformNotSupportedException(); }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs
index cf334af409ac02..ab5da4a00e4491 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -87,123 +88,123 @@ public abstract class PackedSimd
         ///   i8x16.extract_lane_s
         /// </summary>
         [Intrinsic]
-        public static int    ExtractLane(Vector128<sbyte>  value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx16
+        public static int    ExtractLane(Vector128<sbyte>  value, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx16
         /// <summary>
         ///   i8x16.extract_lane_u
         /// </summary>
         [Intrinsic]
-        public static uint   ExtractLane(Vector128<byte>   value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx16
+        public static uint   ExtractLane(Vector128<byte>   value, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx16
         /// <summary>
         ///   i16x8.extract_lane_s
         /// </summary>
         [Intrinsic]
-        public static int    ExtractLane(Vector128<short>  value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx8
+        public static int    ExtractLane(Vector128<short>  value, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx8
         /// <summary>
         ///   i16x8.extract_lane_u
         /// </summary>
         [Intrinsic]
-        public static uint   ExtractLane(Vector128<ushort> value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx8
+        public static uint   ExtractLane(Vector128<ushort> value, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx8
         /// <summary>
         ///   i32x4.extract_lane
         /// </summary>
         [Intrinsic]
-        public static int    ExtractLane(Vector128<int>    value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx4
+        public static int    ExtractLane(Vector128<int>    value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx4
         /// <summary>
         ///   i32x4.extract_lane
         /// </summary>
         [Intrinsic]
-        public static uint   ExtractLane(Vector128<uint>   value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx4
+        public static uint   ExtractLane(Vector128<uint>   value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx4
         /// <summary>
         ///   i64x2.extract_lane
         /// </summary>
         [Intrinsic]
-        public static long   ExtractLane(Vector128<long>   value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx2
+        public static long   ExtractLane(Vector128<long>   value, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx2
         /// <summary>
         ///   i64x2.extract_lane
         /// </summary>
         [Intrinsic]
-        public static ulong  ExtractLane(Vector128<ulong>  value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx2
+        public static ulong  ExtractLane(Vector128<ulong>  value, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx2
         /// <summary>
         ///   f32x4.extract_lane
         /// </summary>
         [Intrinsic]
-        public static float  ExtractLane(Vector128<float>  value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx4
+        public static float  ExtractLane(Vector128<float>  value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx4
         /// <summary>
         ///   f64x2.extract_lane
         /// </summary>
         [Intrinsic]
-        public static double ExtractLane(Vector128<double> value, byte index) => ExtractLane(value, index);    // takes ImmLaneIdx2
+        public static double ExtractLane(Vector128<double> value, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractLane(value, index);    // takes ImmLaneIdx2
         /// <summary>
         ///   i32x4.extract_lane
         /// </summary>
         [Intrinsic]
-        public static nint   ExtractLane(Vector128<nint>   value, byte index) => ExtractLane(value, index);
+        public static nint   ExtractLane(Vector128<nint>   value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractLane(value, index);
         /// <summary>
         ///   i32x4.extract_lane
         /// </summary>
         [Intrinsic]
-        public static nuint  ExtractLane(Vector128<nuint>  value, byte index) => ExtractLane(value, index);
+        public static nuint  ExtractLane(Vector128<nuint>  value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractLane(value, index);
 
         /// <summary>
         ///   i8x16.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, byte imm, int    value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx16
+        public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, [ConstantExpected(Max = (byte)(15))] byte imm, int    value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx16
         /// <summary>
         ///   i8x16.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, byte imm, uint   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx16
+        public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, [ConstantExpected(Max = (byte)(15))] byte imm, uint   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx16
         /// <summary>
         ///   i16x8.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<short>  ReplaceLane(Vector128<short>  vector, byte imm, int    value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx8
+        public static Vector128<short>  ReplaceLane(Vector128<short>  vector, [ConstantExpected(Max = (byte)(7))] byte imm, int    value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx8
         /// <summary>
         ///   i16x8.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, byte imm, uint   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx8
+        public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, [ConstantExpected(Max = (byte)(7))] byte imm, uint   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx8
         /// <summary>
         ///   i32x4.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<int>    ReplaceLane(Vector128<int>    vector, byte imm, int    value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx4
+        public static Vector128<int>    ReplaceLane(Vector128<int>    vector, [ConstantExpected(Max = (byte)(3))] byte imm, int    value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx4
         /// <summary>
         ///   i32x4.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, byte imm, uint   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx4
+        public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, [ConstantExpected(Max = (byte)(3))] byte imm, uint   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx4
         /// <summary>
         ///   i64x2.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<long>   ReplaceLane(Vector128<long>   vector, byte imm, long   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx2
+        public static Vector128<long>   ReplaceLane(Vector128<long>   vector, [ConstantExpected(Max = (byte)(1))] byte imm, long   value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx2
         /// <summary>
         ///   i64x2.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, byte imm, ulong  value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx2
+        public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, [ConstantExpected(Max = (byte)(1))] byte imm, ulong  value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx2
         /// <summary>
         ///   f32x4.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<float>  ReplaceLane(Vector128<float>  vector, byte imm, float  value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx4
+        public static Vector128<float>  ReplaceLane(Vector128<float>  vector, [ConstantExpected(Max = (byte)(3))] byte imm, float  value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx4
         /// <summary>
         ///   f64x2.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<double> ReplaceLane(Vector128<double> vector, byte imm, double value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx2
+        public static Vector128<double> ReplaceLane(Vector128<double> vector, [ConstantExpected(Max = (byte)(1))] byte imm, double value) => ReplaceLane(vector, imm, value);   // takes ImmLaneIdx2
         /// <summary>
         ///   i32x4.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, byte imm, nint   value) => ReplaceLane(vector, imm, value);
+        public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, [ConstantExpected(Max = (byte)(3))] byte imm, nint   value) => ReplaceLane(vector, imm, value);
         /// <summary>
         ///   i32x4.replace_lane
         /// </summary>
         [Intrinsic]
-        public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, byte imm, nuint  value) => ReplaceLane(vector, imm, value);
+        public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, [ConstantExpected(Max = (byte)(3))] byte imm, nuint  value) => ReplaceLane(vector, imm, value);
 
         /// <summary>
         ///   i8x16.shuffle
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs
index 7a67d39891037e..72da97c9c4b77d 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -58,7 +59,7 @@ internal X64() { }
         /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
         ///   AESKEYGENASSIST xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> KeygenAssist(Vector128<byte> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
     }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs
index b72f6e39f708a6..77008b678c92db 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -58,6 +59,6 @@ internal X64() { }
         /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8)
         ///   AESKEYGENASSIST xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control) => KeygenAssist(value, control);
+        public static Vector128<byte> KeygenAssist(Vector128<byte> value, [ConstantExpected] byte control) => KeygenAssist(value, control);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
index 01d674dcec85c2..715cebdfe192fc 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -72,12 +73,12 @@ internal X64() { }
         /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8)
         ///   VBLENDPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8)
         ///   VBLENDPD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask)
@@ -133,22 +134,22 @@ internal X64() { }
         /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8)
         ///   VCMPPS xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8)
         ///   VCMPPD xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8)
         ///   VCMPPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
         ///   VCMPPD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_cmpeq_ps (__m256 a,  __m256 b)
@@ -297,12 +298,12 @@ internal X64() { }
         /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8)
         ///   VCMPSS xmm, xmm, xmm/m32, imm8
         /// </summary>
-        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8)
         ///   VCMPSD xmm, xmm, xmm/m64, imm8
         /// </summary>
-        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_cmpunord_ps (__m256 a,  __m256 b)
@@ -374,7 +375,7 @@ internal X64() { }
         /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8)
         ///   VDPPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_moveldup_ps (__m256 a)
@@ -397,61 +398,61 @@ internal X64() { }
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ExtractVector128(Vector256<byte> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ExtractVector128(Vector256<short> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ExtractVector128(Vector256<int> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ExtractVector128(Vector256<uint> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ExtractVector128(Vector256<long> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<float> ExtractVector128(Vector256<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> ExtractVector128(Vector256<float> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<double> ExtractVector128(Vector256<double> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> ExtractVector128(Vector256<double> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_floor_ps (__m256 a)
@@ -490,61 +491,61 @@ internal X64() { }
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
@@ -792,82 +793,82 @@ internal X64() { }
         /// __m128 _mm_permute_ps (__m128 a, int imm8)
         ///   VPERMILPS xmm, xmm, imm8
         /// </summary>
-        public static Vector128<float> Permute(Vector128<float> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Permute(Vector128<float> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_permute_pd (__m128d a, int imm8)
         ///   VPERMILPD xmm, xmm, imm8
         /// </summary>
-        public static Vector128<double> Permute(Vector128<double> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Permute(Vector128<double> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_permute_ps (__m256 a, int imm8)
         ///   VPERMILPS ymm, ymm, imm8
         /// </summary>
-        public static Vector256<float> Permute(Vector256<float> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Permute(Vector256<float> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_permute_pd (__m256d a, int imm8)
         ///   VPERMILPD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<double> Permute(Vector256<double> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Permute(Vector256<double> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128 _mm_permutevar_ps (__m128 a, __m128i b)
@@ -958,12 +959,12 @@ internal X64() { }
         /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)
         ///   VSHUFPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8)
         ///   VSHUFPD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256 _mm256_sqrt_ps (__m256 a)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs
index 3ab8affba01165..0d13a2bf8607ef 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -73,12 +74,12 @@ internal X64() { }
         /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8)
         ///   VBLENDPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control) => Blend(left, right, control);
+        public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => Blend(left, right, control);
         /// <summary>
         /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8)
         ///   VBLENDPD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control) => Blend(left, right, control);
+        public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => Blend(left, right, control);
 
         /// <summary>
         /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask)
@@ -134,22 +135,22 @@ internal X64() { }
         /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8)
         ///   VCMPPS xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) => Compare(left, right, mode);
+        public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode);
         /// <summary>
         /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8)
         ///   VCMPPD xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) => Compare(left, right, mode);
+        public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode);
         /// <summary>
         /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8)
         ///   VCMPPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode) => Compare(left, right, mode);
+        public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode);
         /// <summary>
         /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8)
         ///   VCMPPD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode) => Compare(left, right, mode);
+        public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode);
 
         /// <summary>
         /// __m256 _mm256_cmpeq_ps (__m256 a,  __m256 b)
@@ -298,12 +299,12 @@ internal X64() { }
         /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8)
         ///   VCMPSS xmm, xmm, xmm/m32, imm8
         /// </summary>
-        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode) => CompareScalar(left, right, mode);
+        public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => CompareScalar(left, right, mode);
         /// <summary>
         /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8)
         ///   VCMPSD xmm, xmm, xmm/m64, imm8
         /// </summary>
-        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode) => CompareScalar(left, right, mode);
+        public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => CompareScalar(left, right, mode);
 
         /// <summary>
         /// __m256 _mm256_cmpunord_ps (__m256 a,  __m256 b)
@@ -375,7 +376,7 @@ internal X64() { }
         /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8)
         ///   VDPPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control) => DotProduct(left, right, control);
+        public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => DotProduct(left, right, control);
 
         /// <summary>
         /// __m256 _mm256_moveldup_ps (__m256 a)
@@ -398,61 +399,61 @@ internal X64() { }
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<byte> ExtractVector128(Vector256<byte> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<short> ExtractVector128(Vector256<short> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<short> ExtractVector128(Vector256<short> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<int> ExtractVector128(Vector256<int> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<int> ExtractVector128(Vector256<int> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<uint> ExtractVector128(Vector256<uint> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<long> ExtractVector128(Vector256<long> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<long> ExtractVector128(Vector256<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<float> ExtractVector128(Vector256<float> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<float> ExtractVector128(Vector256<float> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8)
         ///   VEXTRACTF128 xmm/m128, ymm, imm8
         /// </summary>
-        public static Vector128<double> ExtractVector128(Vector256<double> value, byte index) => ExtractVector128(value, index);
+        public static Vector128<double> ExtractVector128(Vector256<double> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m256 _mm256_floor_ps (__m256 a)
@@ -491,61 +492,61 @@ internal X64() { }
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8)
         ///   VINSERTF128 ymm, ymm, xmm/m128, imm8
         /// </summary>
-        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, byte index) => InsertVector128(value, data, index);
+        public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr)
@@ -793,82 +794,82 @@ internal X64() { }
         /// __m128 _mm_permute_ps (__m128 a, int imm8)
         ///   VPERMILPS xmm, xmm, imm8
         /// </summary>
-        public static Vector128<float> Permute(Vector128<float> value, byte control) => Permute(value, control);
+        public static Vector128<float> Permute(Vector128<float> value, [ConstantExpected] byte control) => Permute(value, control);
         /// <summary>
         /// __m128d _mm_permute_pd (__m128d a, int imm8)
         ///   VPERMILPD xmm, xmm, imm8
         /// </summary>
-        public static Vector128<double> Permute(Vector128<double> value, byte control) => Permute(value, control);
+        public static Vector128<double> Permute(Vector128<double> value, [ConstantExpected] byte control) => Permute(value, control);
 
         /// <summary>
         /// __m256 _mm256_permute_ps (__m256 a, int imm8)
         ///   VPERMILPS ymm, ymm, imm8
         /// </summary>
-        public static Vector256<float> Permute(Vector256<float> value, byte control) => Permute(value, control);
+        public static Vector256<float> Permute(Vector256<float> value, [ConstantExpected] byte control) => Permute(value, control);
         /// <summary>
         /// __m256d _mm256_permute_pd (__m256d a, int imm8)
         ///   VPERMILPD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<double> Permute(Vector256<double> value, byte control) => Permute(value, control);
+        public static Vector256<double> Permute(Vector256<double> value, [ConstantExpected] byte control) => Permute(value, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8)
         ///   VPERM2F128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control) => Permute2x128(left, right, control);
+        public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m128 _mm_permutevar_ps (__m128 a, __m128i b)
@@ -959,12 +960,12 @@ internal X64() { }
         /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8)
         ///   VSHUFPS ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control) => Shuffle(value, right, control);
+        public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, [ConstantExpected] byte control) => Shuffle(value, right, control);
         /// <summary>
         /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8)
         ///   VSHUFPD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control) => Shuffle(value, right, control);
+        public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, [ConstantExpected] byte control) => Shuffle(value, right, control);
 
         /// <summary>
         /// __m256 _mm256_sqrt_ps (__m256 a)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
index 28ae4c77ff67a9..9e8a0f8e017166 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -106,55 +107,55 @@ internal X64() { }
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
@@ -253,32 +254,32 @@ internal X64() { }
         /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
         ///   VPBLENDD xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
         ///   VPBLENDD xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDW ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDW ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
@@ -803,339 +804,339 @@ internal X64() { }
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<byte> ExtractVector128(Vector256<byte> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<short> ExtractVector128(Vector256<short> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<short> ExtractVector128(Vector256<short> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<ushort> ExtractVector128(Vector256<ushort> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<int> ExtractVector128(Vector256<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<int> ExtractVector128(Vector256<int> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<uint> ExtractVector128(Vector256<uint> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<long> ExtractVector128(Vector256<long> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<long> ExtractVector128(Vector256<long> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector128<ulong> ExtractVector128(Vector256<ulong> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale)
         ///   VGATHERDPS xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
         ///   VGATHERDPD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale)
         ///   VGATHERQPS xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale)
         ///   VGATHERQPD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale)
         ///   VGATHERDPS ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale)
         ///   VGATHERDPD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
         ///   VPGATHERQD xmm, vm64y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale)
         ///   VPGATHERQD xmm, vm64y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
         ///   VPGATHERQQ ymm, vm64y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale)
         ///   VPGATHERQQ ymm, vm64y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale)
         ///   VGATHERQPS xmm, vm64y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale)
         ///   VGATHERQPD ymm, vm64y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
         ///   VGATHERDPS xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
         ///   VGATHERDPD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale)
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale)
         ///   VGATHERQPS xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale)
         ///   VGATHERQPD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale)
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale)
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale)
         ///   VPGATHERDPS ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale)
         ///   VPGATHERDPD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
         ///   VPGATHERQD xmm, vm32y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale)
         ///   VPGATHERQD xmm, vm32y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
         ///   VPGATHERQQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale)
         ///   VPGATHERQQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale)
         ///   VGATHERQPS xmm, vm32y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale)
         ///   VGATHERQPD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale) { throw new PlatformNotSupportedException(); }
+        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b)
@@ -1175,49 +1176,49 @@ internal X64() { }
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr)
@@ -1433,7 +1434,7 @@ internal X64() { }
         /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8)
         ///   VMPSADBW ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b)
@@ -1551,58 +1552,58 @@ internal X64() { }
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static new Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
         ///   VPERMQ ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<long> Permute4x64(Vector256<long> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> Permute4x64(Vector256<long> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
         ///   VPERMQ ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> Permute4x64(Vector256<ulong> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8)
         ///   VPERMPD ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Permute4x64(Vector256<double> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<double> Permute4x64(Vector256<double> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
@@ -1655,73 +1656,73 @@ internal X64() { }
         /// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
         ///   VPSLLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
         ///   VPSLLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
         ///   VPSLLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
         ///   VPSLLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
         ///   VPSLLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
         ///   VPSLLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
@@ -1780,12 +1781,12 @@ internal X64() { }
         /// __m256i _mm256_srai_epi16 (__m256i a, int imm8)
         ///   VPSRAW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_srai_epi32 (__m256i a, int imm8)
         ///   VPSRAD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count)
@@ -1834,73 +1835,73 @@ internal X64() { }
         /// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
         ///   VPSRLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
         ///   VPSRLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
         ///   VPSRLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
         ///   VPSRLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
         ///   VPSRLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
         ///   VPSRLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
@@ -1958,34 +1959,34 @@ internal X64() { }
         /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
         ///   VPSHUFD ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Shuffle(Vector256<int> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<int> Shuffle(Vector256<int> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
         ///   VPSHUFD ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Shuffle(Vector256<uint> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<uint> Shuffle(Vector256<uint> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
         ///   VPSHUFHW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShuffleHigh(Vector256<short> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
         ///   VPSHUFHW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
         ///   VPSHUFLW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> ShuffleLow(Vector256<short> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<short> ShuffleLow(Vector256<short> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
         ///   VPSHUFLW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs
index ad5eca4432518f..e275baffece76e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -106,55 +107,55 @@ internal X64() { }
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count)
         ///   VPALIGNR ymm, ymm, ymm/m256, imm8
         /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_and_si256 (__m256i a, __m256i b)
@@ -253,32 +254,32 @@ internal X64() { }
         /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
         ///   VPBLENDD xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control) => Blend(left, right, control);
+        public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, [ConstantExpected] byte control) => Blend(left, right, control);
         /// <summary>
         /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8)
         ///   VPBLENDD xmm, xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control) => Blend(left, right, control);
+        public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, [ConstantExpected] byte control) => Blend(left, right, control);
         /// <summary>
         /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDW ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control) => Blend(left, right, control);
+        public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) => Blend(left, right, control);
         /// <summary>
         /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDW ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control) => Blend(left, right, control);
+        public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) => Blend(left, right, control);
         /// <summary>
         /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control) => Blend(left, right, control);
+        public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Blend(left, right, control);
         /// <summary>
         /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8)
         ///   VPBLENDD ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control) => Blend(left, right, control);
+        public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Blend(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask)
@@ -802,56 +803,56 @@ internal X64() { }
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<byte> ExtractVector128(Vector256<byte> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<byte> ExtractVector128(Vector256<byte> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<short> ExtractVector128(Vector256<short> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<short> ExtractVector128(Vector256<short> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<ushort> ExtractVector128(Vector256<ushort> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<int> ExtractVector128(Vector256<int> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<int> ExtractVector128(Vector256<int> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<uint> ExtractVector128(Vector256<uint> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<uint> ExtractVector128(Vector256<uint> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<long> ExtractVector128(Vector256<long> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<long> ExtractVector128(Vector256<long> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8)
         ///   VEXTRACTI128 xmm, ymm, imm8
         /// </summary>
-        public static new Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index) => ExtractVector128(value, index);
+        public static new Vector128<ulong> ExtractVector128(Vector256<ulong> value, [ConstantExpected] byte index) => ExtractVector128(value, index);
 
         /// <summary>
         /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale)
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -867,7 +868,7 @@ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -883,7 +884,7 @@ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector12
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -899,7 +900,7 @@ public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector12
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -915,7 +916,7 @@ public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector
         ///   VGATHERDPS xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -931,7 +932,7 @@ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector
         ///   VGATHERDPD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -947,7 +948,7 @@ public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vect
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale)
+        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -963,7 +964,7 @@ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector128<
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale)
+        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -979,7 +980,7 @@ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector12
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale)
+        public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -995,7 +996,7 @@ public static unsafe Vector128<long> GatherVector128(long* baseAddress, Vector12
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale)
+        public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1011,7 +1012,7 @@ public static unsafe Vector128<ulong> GatherVector128(ulong* baseAddress, Vector
         ///   VGATHERQPS xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale)
+        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1027,7 +1028,7 @@ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector
         ///   VGATHERQPD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale)
+        public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1043,7 +1044,7 @@ public static unsafe Vector128<double> GatherVector128(double* baseAddress, Vect
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale)
+        public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1059,7 +1060,7 @@ public static unsafe Vector256<int> GatherVector256(int* baseAddress, Vector256<
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale)
+        public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1075,7 +1076,7 @@ public static unsafe Vector256<uint> GatherVector256(uint* baseAddress, Vector25
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1091,7 +1092,7 @@ public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector12
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1107,7 +1108,7 @@ public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector
         ///   VGATHERDPS ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale)
+        public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1123,7 +1124,7 @@ public static unsafe Vector256<float> GatherVector256(float* baseAddress, Vector
         ///   VGATHERDPD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale)
+        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1139,7 +1140,7 @@ public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vect
         ///   VPGATHERQD xmm, vm64y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale)
+        public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1155,7 +1156,7 @@ public static unsafe Vector128<int> GatherVector128(int* baseAddress, Vector256<
         ///   VPGATHERQD xmm, vm64y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale)
+        public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1171,7 +1172,7 @@ public static unsafe Vector128<uint> GatherVector128(uint* baseAddress, Vector25
         ///   VPGATHERQQ ymm, vm64y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale)
+        public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1187,7 +1188,7 @@ public static unsafe Vector256<long> GatherVector256(long* baseAddress, Vector25
         ///   VPGATHERQQ ymm, vm64y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale)
+        public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1203,7 +1204,7 @@ public static unsafe Vector256<ulong> GatherVector256(ulong* baseAddress, Vector
         ///   VGATHERQPS xmm, vm64y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale)
+        public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1219,7 +1220,7 @@ public static unsafe Vector128<float> GatherVector128(float* baseAddress, Vector
         ///   VGATHERQPD ymm, vm64y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale)
+        public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1236,7 +1237,7 @@ public static unsafe Vector256<double> GatherVector256(double* baseAddress, Vect
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale)
+        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1252,7 +1253,7 @@ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, i
         ///   VPGATHERDD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale)
+        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1268,7 +1269,7 @@ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source,
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale)
+        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1284,7 +1285,7 @@ public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source,
         ///   VPGATHERDQ xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale)
+        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1300,7 +1301,7 @@ public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> sourc
         ///   VGATHERDPS xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale)
+        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1316,7 +1317,7 @@ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> sourc
         ///   VGATHERDPD xmm, vm32x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale)
+        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1332,7 +1333,7 @@ public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> sou
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale)
+        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1348,7 +1349,7 @@ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, i
         ///   VPGATHERQD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale)
+        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1364,7 +1365,7 @@ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source,
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale)
+        public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1380,7 +1381,7 @@ public static unsafe Vector128<long> GatherMaskVector128(Vector128<long> source,
         ///   VPGATHERQQ xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale)
+        public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1396,7 +1397,7 @@ public static unsafe Vector128<ulong> GatherMaskVector128(Vector128<ulong> sourc
         ///   VGATHERQPS xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale)
+        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1412,7 +1413,7 @@ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> sourc
         ///   VGATHERQPD xmm, vm64x, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale)
+        public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1428,7 +1429,7 @@ public static unsafe Vector128<double> GatherMaskVector128(Vector128<double> sou
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale)
+        public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1444,7 +1445,7 @@ public static unsafe Vector256<int> GatherMaskVector256(Vector256<int> source, i
         ///   VPGATHERDD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale)
+        public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1460,7 +1461,7 @@ public static unsafe Vector256<uint> GatherMaskVector256(Vector256<uint> source,
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale)
+        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1476,7 +1477,7 @@ public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source,
         ///   VPGATHERDQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale)
+        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1492,7 +1493,7 @@ public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> sourc
         ///   VPGATHERDPS ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale)
+        public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1508,7 +1509,7 @@ public static unsafe Vector256<float> GatherMaskVector256(Vector256<float> sourc
         ///   VPGATHERDPD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale)
+        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1524,7 +1525,7 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         ///   VPGATHERQD xmm, vm32y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale)
+        public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1540,7 +1541,7 @@ public static unsafe Vector128<int> GatherMaskVector128(Vector128<int> source, i
         ///   VPGATHERQD xmm, vm32y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale)
+        public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1556,7 +1557,7 @@ public static unsafe Vector128<uint> GatherMaskVector128(Vector128<uint> source,
         ///   VPGATHERQQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale)
+        public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1572,7 +1573,7 @@ public static unsafe Vector256<long> GatherMaskVector256(Vector256<long> source,
         ///   VPGATHERQQ ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale)
+        public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1588,7 +1589,7 @@ public static unsafe Vector256<ulong> GatherMaskVector256(Vector256<ulong> sourc
         ///   VGATHERQPS xmm, vm32y, xmm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale)
+        public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1604,7 +1605,7 @@ public static unsafe Vector128<float> GatherMaskVector128(Vector128<float> sourc
         ///   VGATHERQPD ymm, vm32y, ymm
         /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown.
         /// </summary>
-        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale)
+        public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale)
         {
             return scale switch
             {
@@ -1654,49 +1655,49 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8)
         ///   VINSERTI128 ymm, ymm, xmm, imm8
         /// </summary>
-        public static new Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index) => InsertVector128(value, data, index);
+        public static new Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, [ConstantExpected] byte index) => InsertVector128(value, data, index);
 
         /// <summary>
         /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr)
@@ -1912,7 +1913,7 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8)
         ///   VMPSADBW ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);
+        public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);
 
         /// <summary>
         /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b)
@@ -2030,58 +2031,58 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
         /// <summary>
         /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8)
         ///   VPERM2I128 ymm, ymm, ymm/m256, imm8
         /// </summary>
-        public static new Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control) => Permute2x128(left, right, control);
+        public static new Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected] byte control) => Permute2x128(left, right, control);
 
         /// <summary>
         /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
         ///   VPERMQ ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<long> Permute4x64(Vector256<long> value, byte control) => Permute4x64(value, control);
+        public static Vector256<long> Permute4x64(Vector256<long> value, [ConstantExpected] byte control) => Permute4x64(value, control);
         /// <summary>
         /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8)
         ///   VPERMQ ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control) => Permute4x64(value, control);
+        public static Vector256<ulong> Permute4x64(Vector256<ulong> value, [ConstantExpected] byte control) => Permute4x64(value, control);
         /// <summary>
         /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8)
         ///   VPERMPD ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<double> Permute4x64(Vector256<double> value, byte control) => Permute4x64(value, control);
+        public static Vector256<double> Permute4x64(Vector256<double> value, [ConstantExpected] byte control) => Permute4x64(value, control);
 
         /// <summary>
         /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx)
@@ -2134,73 +2135,73 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
         ///   VPSLLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m256i _mm256_slli_epi16 (__m256i a, int imm8)
         ///   VPSLLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
         ///   VPSLLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m256i _mm256_slli_epi32 (__m256i a, int imm8)
         ///   VPSLLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
         ///   VPSLLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m256i _mm256_slli_epi64 (__m256i a, int imm8)
         ///   VPSLLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8)
         ///   VPSLLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
 
         /// <summary>
         /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count)
@@ -2259,12 +2260,12 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_srai_epi16 (__m256i a, int imm8)
         ///   VPSRAW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count);
         /// <summary>
         /// __m256i _mm256_srai_epi32 (__m256i a, int imm8)
         ///   VPSRAD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count)
@@ -2313,73 +2314,73 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
         ///   VPSRLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m256i _mm256_srli_epi16 (__m256i a, int imm8)
         ///   VPSRLW ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
         ///   VPSRLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m256i _mm256_srli_epi32 (__m256i a, int imm8)
         ///   VPSRLD ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
         ///   VPSRLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m256i _mm256_srli_epi64 (__m256i a, int imm8)
         ///   VPSRLQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8)
         ///   VPSRLDQ ymm, ymm, imm8
         /// </summary>
-        public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
 
         /// <summary>
         /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count)
@@ -2437,34 +2438,34 @@ public static unsafe Vector256<double> GatherMaskVector256(Vector256<double> sou
         /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
         ///   VPSHUFD ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<int> Shuffle(Vector256<int> value, byte control) => Shuffle(value, control);
+        public static Vector256<int> Shuffle(Vector256<int> value, [ConstantExpected] byte control) => Shuffle(value, control);
         /// <summary>
         /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8)
         ///   VPSHUFD ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<uint> Shuffle(Vector256<uint> value, byte control) => Shuffle(value, control);
+        public static Vector256<uint> Shuffle(Vector256<uint> value, [ConstantExpected] byte control) => Shuffle(value, control);
 
         /// <summary>
         /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
         ///   VPSHUFHW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control) => ShuffleHigh(value, control);
+        public static Vector256<short> ShuffleHigh(Vector256<short> value, [ConstantExpected] byte control) => ShuffleHigh(value, control);
         /// <summary>
         /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8)
         ///   VPSHUFHW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control) => ShuffleHigh(value, control);
+        public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, [ConstantExpected] byte control) => ShuffleHigh(value, control);
 
         /// <summary>
         /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
         ///   VPSHUFLW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<short> ShuffleLow(Vector256<short> value, byte control) => ShuffleLow(value, control);
+        public static Vector256<short> ShuffleLow(Vector256<short> value, [ConstantExpected] byte control) => ShuffleLow(value, control);
         /// <summary>
         /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8)
         ///   VPSHUFLW ymm, ymm/m256, imm8
         /// </summary>
-        public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control) => ShuffleLow(value, control);
+        public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, [ConstantExpected] byte control) => ShuffleLow(value, control);
 
         /// <summary>
         /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs
index eb1cd76c6c56f3..6cb481911325cc 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -28,11 +29,11 @@ internal X64() { }
         /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
         ///   PCLMULQDQ xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<long> CarrylessMultiply(Vector128<long> left, Vector128<long> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> CarrylessMultiply(Vector128<long> left, Vector128<long> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
         ///   PCLMULQDQ xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ulong> CarrylessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> CarrylessMultiply(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs
index b20c8c7607ff06..0423cd49d726f9 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -28,11 +29,11 @@ internal X64() { }
         /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
         ///   PCLMULQDQ xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<long> CarrylessMultiply(Vector128<long> left, Vector128<long> right, byte control) => CarrylessMultiply(left, right, control);
+        public static Vector128<long> CarrylessMultiply(Vector128<long> left, Vector128<long> right, [ConstantExpected] byte control) => CarrylessMultiply(left, right, control);
         /// <summary>
         /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8)
         ///   PCLMULQDQ xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ulong> CarrylessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control) => CarrylessMultiply(left, right, control);
+        public static Vector128<ulong> CarrylessMultiply(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected] byte control) => CarrylessMultiply(left, right, control);
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs
index 39bd4eb1cfac84..5f7655fdb367c4 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -477,7 +478,7 @@ internal X64() { }
         /// __m128 _mm_shuffle_ps (__m128 a,  __m128 b, unsigned int control)
         ///   SHUFPS xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128 _mm_sqrt_ps (__m128 a)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs
index 2b0fa3aa6d6eaa..3ca759b1472551 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -476,7 +477,7 @@ internal X64() { }
         /// __m128 _mm_shuffle_ps (__m128 a,  __m128 b, unsigned int control)
         ///   SHUFPS xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control) => Shuffle(left, right, control);
+        public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) => Shuffle(left, right, control);
 
         /// <summary>
         /// __m128 _mm_sqrt_ps (__m128 a)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs
index c4f708b379e718..3b6ae16a2d1af7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -643,18 +644,18 @@ internal X64() { }
         /// int _mm_extract_epi16 (__m128i a,  int immediate)
         ///   PEXTRW reg, xmm, imm8
         /// </summary>
-        public static ushort Extract(Vector128<ushort> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static ushort Extract(Vector128<ushort> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
         ///   PINSRW xmm, reg/m16, imm8
         /// </summary>
-        public static Vector128<short> Insert(Vector128<short> value, short data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> Insert(Vector128<short> value, short data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
         ///   PINSRW xmm, reg/m16, imm8
         /// </summary>
-        public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
@@ -1005,39 +1006,39 @@ internal X64() { }
         /// __m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
         ///   PSHUFD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<int> Shuffle(Vector128<int> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Shuffle(Vector128<int> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
         ///   PSHUFD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<uint> Shuffle(Vector128<uint> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Shuffle(Vector128<uint> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_shuffle_pd (__m128d a,  __m128d b, int immediate)
         ///   SHUFPD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_shufflehi_epi16 (__m128i a,  int immediate)
         ///   PSHUFHW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShuffleHigh(Vector128<short> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_shufflehi_epi16 (__m128i a,  int control)
         ///   PSHUFHW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_shufflelo_epi16 (__m128i a,  int control)
         ///   PSHUFLW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShuffleLow(Vector128<short> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_shufflelo_epi16 (__m128i a,  int control)
         ///   PSHUFLW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_sll_epi16 (__m128i a, __m128i count)
@@ -1074,73 +1075,73 @@ internal X64() { }
         /// __m128i _mm_slli_epi16 (__m128i a,  int immediate)
         ///   PSLLW xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_slli_epi16 (__m128i a,  int immediate)
         ///   PSLLW xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_slli_epi32 (__m128i a,  int immediate)
         ///   PSLLD xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_slli_epi32 (__m128i a,  int immediate)
         ///   PSLLD xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_slli_epi64 (__m128i a,  int immediate)
         ///   PSLLQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_slli_epi64 (__m128i a,  int immediate)
         ///   PSLLQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_sra_epi16 (__m128i a, __m128i count)
@@ -1157,12 +1158,12 @@ internal X64() { }
         /// __m128i _mm_srai_epi16 (__m128i a,  int immediate)
         ///   PSRAW xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_srai_epi32 (__m128i a,  int immediate)
         ///   PSRAD xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_srl_epi16 (__m128i a, __m128i count)
@@ -1199,73 +1200,73 @@ internal X64() { }
         /// __m128i _mm_srli_epi16 (__m128i a,  int immediate)
         ///   PSRLW xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_srli_epi16 (__m128i a,  int immediate)
         ///   PSRLW xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_srli_epi32 (__m128i a,  int immediate)
         ///   PSRLD xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_srli_epi32 (__m128i a,  int immediate)
         ///   PSRLD xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_srli_epi64 (__m128i a,  int immediate)
         ///   PSRLQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_srli_epi64 (__m128i a,  int immediate)
         ///   PSRLQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128d _mm_sqrt_pd (__m128d a)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs
index 8dd40ac3bf4b0e..9e4a8d673bcd75 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -647,18 +648,18 @@ internal X64() { }
         /// int _mm_extract_epi16 (__m128i a,  int immediate)
         ///   PEXTRW reg, xmm, imm8
         /// </summary>
-        public static ushort Extract(Vector128<ushort> value, byte index) => Extract(value, index);
+        public static ushort Extract(Vector128<ushort> value, [ConstantExpected] byte index) => Extract(value, index);
 
         /// <summary>
         /// __m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
         ///   PINSRW xmm, reg/m16, imm8
         /// </summary>
-        public static Vector128<short> Insert(Vector128<short> value, short data, byte index) => Insert(value, data, index);
+        public static Vector128<short> Insert(Vector128<short> value, short data, [ConstantExpected] byte index) => Insert(value, data, index);
         /// <summary>
         /// __m128i _mm_insert_epi16 (__m128i a,  int i, int immediate)
         ///   PINSRW xmm, reg/m16, imm8
         /// </summary>
-        public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, byte index) => Insert(value, data, index);
+        public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, [ConstantExpected] byte index) => Insert(value, data, index);
 
         /// <summary>
         /// __m128i _mm_loadu_si128 (__m128i const* mem_address)
@@ -1009,39 +1010,39 @@ internal X64() { }
         /// __m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
         ///   PSHUFD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<int> Shuffle(Vector128<int> value, byte control) => Shuffle(value, control);
+        public static Vector128<int> Shuffle(Vector128<int> value, [ConstantExpected] byte control) => Shuffle(value, control);
         /// <summary>
         /// __m128i _mm_shuffle_epi32 (__m128i a,  int immediate)
         ///   PSHUFD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<uint> Shuffle(Vector128<uint> value, byte control) => Shuffle(value, control);
+        public static Vector128<uint> Shuffle(Vector128<uint> value, [ConstantExpected] byte control) => Shuffle(value, control);
         /// <summary>
         /// __m128d _mm_shuffle_pd (__m128d a,  __m128d b, int immediate)
         ///   SHUFPD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control) => Shuffle(left, right, control);
+        public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, [ConstantExpected] byte control) => Shuffle(left, right, control);
 
         /// <summary>
         /// __m128i _mm_shufflehi_epi16 (__m128i a,  int immediate)
         ///   PSHUFHW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control) => ShuffleHigh(value, control);
+        public static Vector128<short> ShuffleHigh(Vector128<short> value, [ConstantExpected] byte control) => ShuffleHigh(value, control);
         /// <summary>
         /// __m128i _mm_shufflehi_epi16 (__m128i a,  int control)
         ///   PSHUFHW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control) => ShuffleHigh(value, control);
+        public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, [ConstantExpected] byte control) => ShuffleHigh(value, control);
 
         /// <summary>
         /// __m128i _mm_shufflelo_epi16 (__m128i a,  int control)
         ///   PSHUFLW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<short> ShuffleLow(Vector128<short> value, byte control) => ShuffleLow(value, control);
+        public static Vector128<short> ShuffleLow(Vector128<short> value, [ConstantExpected] byte control) => ShuffleLow(value, control);
         /// <summary>
         /// __m128i _mm_shufflelo_epi16 (__m128i a,  int control)
         ///   PSHUFLW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control) => ShuffleLow(value, control);
+        public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, [ConstantExpected] byte control) => ShuffleLow(value, control);
 
         /// <summary>
         /// __m128i _mm_sll_epi16 (__m128i a, __m128i count)
@@ -1078,73 +1079,73 @@ internal X64() { }
         /// __m128i _mm_slli_epi16 (__m128i a,  int immediate)
         ///   PSLLW xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m128i _mm_slli_epi16 (__m128i a,  int immediate)
         ///   PSLLW xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m128i _mm_slli_epi32 (__m128i a,  int immediate)
         ///   PSLLD xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m128i _mm_slli_epi32 (__m128i a,  int immediate)
         ///   PSLLD xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m128i _mm_slli_epi64 (__m128i a,  int immediate)
         ///   PSLLQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
         /// <summary>
         /// __m128i _mm_slli_epi64 (__m128i a,  int immediate)
         ///   PSLLQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count) => ShiftLeftLogical(value, count);
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
 
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bslli_si128 (__m128i a, int imm8)
         ///   PSLLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
+        public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
 
         /// <summary>
         /// __m128i _mm_sra_epi16 (__m128i a, __m128i count)
@@ -1161,12 +1162,12 @@ internal X64() { }
         /// __m128i _mm_srai_epi16 (__m128i a,  int immediate)
         ///   PSRAW xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count);
         /// <summary>
         /// __m128i _mm_srai_epi32 (__m128i a,  int immediate)
         ///   PSRAD xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count) => ShiftRightArithmetic(value, count);
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count);
 
         /// <summary>
         /// __m128i _mm_srl_epi16 (__m128i a, __m128i count)
@@ -1203,73 +1204,73 @@ internal X64() { }
         /// __m128i _mm_srli_epi16 (__m128i a,  int immediate)
         ///   PSRLW xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m128i _mm_srli_epi16 (__m128i a,  int immediate)
         ///   PSRLW xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m128i _mm_srli_epi32 (__m128i a,  int immediate)
         ///   PSRLD xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m128i _mm_srli_epi32 (__m128i a,  int immediate)
         ///   PSRLD xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m128i _mm_srli_epi64 (__m128i a,  int immediate)
         ///   PSRLQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
         /// <summary>
         /// __m128i _mm_srli_epi64 (__m128i a,  int immediate)
         ///   PSRLQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count) => ShiftRightLogical(value, count);
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
 
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
         /// <summary>
         /// __m128i _mm_bsrli_si128 (__m128i a, int imm8)
         ///   PSRLDQ xmm, imm8
         /// </summary>
-        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
+        public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
 
         /// <summary>
         /// __m128d _mm_sqrt_pd (__m128d a)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs
index 618f05c5cdd296..c3a8d1216d477e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -28,51 +29,51 @@ internal X64() { }
             ///   PEXTRQ reg/m64, xmm, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static long Extract(Vector128<long> value, byte index) { throw new PlatformNotSupportedException(); }
+            public static long Extract(Vector128<long> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
             /// <summary>
             /// __int64 _mm_extract_epi64 (__m128i a, const int imm8)
             ///   PEXTRQ reg/m64, xmm, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static ulong Extract(Vector128<ulong> value, byte index) { throw new PlatformNotSupportedException(); }
+            public static ulong Extract(Vector128<ulong> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
             /// <summary>
             /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
             ///   PINSRQ xmm, reg/m64, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static Vector128<long> Insert(Vector128<long> value, long data, byte index) { throw new PlatformNotSupportedException(); }
+            public static Vector128<long> Insert(Vector128<long> value, long data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
             /// <summary>
             /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
             ///   PINSRQ xmm, reg/m64, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, byte index) { throw new PlatformNotSupportedException(); }
+            public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         }
 
         /// <summary>
         /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
         ///   PBLENDW xmm, xmm/m128 imm8
         /// </summary>
-        public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
         ///   PBLENDW xmm, xmm/m128 imm8
         /// </summary>
-        public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8)
         ///   BLENDPS xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8)
         ///   BLENDPD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
@@ -303,33 +304,33 @@ internal X64() { }
         /// __m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8)
         ///   DPPS xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> DotProduct(Vector128<float> left, Vector128<float> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> DotProduct(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8)
         ///   DPPD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> DotProduct(Vector128<double> left, Vector128<double> right, byte control) { throw new PlatformNotSupportedException(); }
+        public static Vector128<double> DotProduct(Vector128<double> left, Vector128<double> right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// int _mm_extract_epi8 (__m128i a, const int imm8)
         ///   PEXTRB reg/m8, xmm, imm8
         /// </summary>
-        public static byte Extract(Vector128<byte> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static byte Extract(Vector128<byte> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// int _mm_extract_epi32 (__m128i a, const int imm8)
         ///   PEXTRD reg/m32, xmm, imm8
         /// </summary>
-        public static int Extract(Vector128<int> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static int Extract(Vector128<int> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// int _mm_extract_epi32 (__m128i a, const int imm8)
         ///   PEXTRD reg/m32, xmm, imm8
         /// </summary>
-        public static uint Extract(Vector128<uint> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static uint Extract(Vector128<uint> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// int _mm_extract_ps (__m128 a, const int imm8)
         ///   EXTRACTPS xmm, xmm/m32, imm8
         /// </summary>
-        public static float Extract(Vector128<float> value, byte index) { throw new PlatformNotSupportedException(); }
+        public static float Extract(Vector128<float> value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128 _mm_floor_ps (__m128 a)
@@ -370,27 +371,27 @@ internal X64() { }
         /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
         ///   PINSRB xmm, reg/m8, imm8
         /// </summary>
-        public static Vector128<sbyte> Insert(Vector128<sbyte> value, sbyte data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> Insert(Vector128<sbyte> value, sbyte data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
         ///   PINSRB xmm, reg/m8, imm8
         /// </summary>
-        public static Vector128<byte> Insert(Vector128<byte> value, byte data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> Insert(Vector128<byte> value, byte data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
         ///   PINSRD xmm, reg/m32, imm8
         /// </summary>
-        public static Vector128<int> Insert(Vector128<int> value, int data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> Insert(Vector128<int> value, int data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
         ///   PINSRD xmm, reg/m32, imm8
         /// </summary>
-        public static Vector128<uint> Insert(Vector128<uint> value, uint data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> Insert(Vector128<uint> value, uint data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
         /// <summary>
         /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8)
         ///   INSERTPS xmm, xmm/m32, imm8
         /// </summary>
-        public static Vector128<float> Insert(Vector128<float> value, Vector128<float> data, byte index) { throw new PlatformNotSupportedException(); }
+        public static Vector128<float> Insert(Vector128<float> value, Vector128<float> data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_max_epi8 (__m128i a, __m128i b)
@@ -444,7 +445,7 @@ internal X64() { }
         /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8)
         ///   MPSADBW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_mul_epi32 (__m128i a, __m128i b)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs
index 06e676262602f3..46e8b7aeb94698 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -28,51 +29,51 @@ internal X64() { }
             ///   PEXTRQ reg/m64, xmm, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static long Extract(Vector128<long> value, byte index) => Extract(value, index);
+            public static long Extract(Vector128<long> value, [ConstantExpected] byte index) => Extract(value, index);
             /// <summary>
             /// __int64 _mm_extract_epi64 (__m128i a, const int imm8)
             ///   PEXTRQ reg/m64, xmm, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static ulong Extract(Vector128<ulong> value, byte index) => Extract(value, index);
+            public static ulong Extract(Vector128<ulong> value, [ConstantExpected] byte index) => Extract(value, index);
 
             /// <summary>
             /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
             ///   PINSRQ xmm, reg/m64, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static Vector128<long> Insert(Vector128<long> value, long data, byte index) => Insert(value, data, index);
+            public static Vector128<long> Insert(Vector128<long> value, long data, [ConstantExpected] byte index) => Insert(value, data, index);
             /// <summary>
             /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8)
             ///   PINSRQ xmm, reg/m64, imm8
             /// This intrinsic is only available on 64-bit processes
             /// </summary>
-            public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, byte index) => Insert(value, data, index);
+            public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, [ConstantExpected] byte index) => Insert(value, data, index);
         }
 
         /// <summary>
         /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
         ///   PBLENDW xmm, xmm/m128 imm8
         /// </summary>
-        public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control) => Blend(left, right, control);
+        public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, [ConstantExpected] byte control) => Blend(left, right, control);
 
         /// <summary>
         /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
         ///   PBLENDW xmm, xmm/m128 imm8
         /// </summary>
-        public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control) => Blend(left, right, control);
+        public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected] byte control) => Blend(left, right, control);
 
         /// <summary>
         /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8)
         ///   BLENDPS xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control) => Blend(left, right, control);
+        public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) => Blend(left, right, control);
 
         /// <summary>
         /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8)
         ///   BLENDPD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control) => Blend(left, right, control);
+        public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, [ConstantExpected] byte control) => Blend(left, right, control);
 
         /// <summary>
         /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
@@ -303,33 +304,33 @@ internal X64() { }
         /// __m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8)
         ///   DPPS xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<float> DotProduct(Vector128<float> left, Vector128<float> right, byte control) => DotProduct(left, right, control);
+        public static Vector128<float> DotProduct(Vector128<float> left, Vector128<float> right, [ConstantExpected] byte control) => DotProduct(left, right, control);
         /// <summary>
         /// __m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8)
         ///   DPPD xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<double> DotProduct(Vector128<double> left, Vector128<double> right, byte control) => DotProduct(left, right, control);
+        public static Vector128<double> DotProduct(Vector128<double> left, Vector128<double> right, [ConstantExpected] byte control) => DotProduct(left, right, control);
 
         /// <summary>
         /// int _mm_extract_epi8 (__m128i a, const int imm8)
         ///   PEXTRB reg/m8, xmm, imm8
         /// </summary>
-        public static byte Extract(Vector128<byte> value, byte index) => Extract(value, index);
+        public static byte Extract(Vector128<byte> value, [ConstantExpected] byte index) => Extract(value, index);
         /// <summary>
         /// int _mm_extract_epi32 (__m128i a, const int imm8)
         ///   PEXTRD reg/m32, xmm, imm8
         /// </summary>
-        public static int Extract(Vector128<int> value, byte index) => Extract(value, index);
+        public static int Extract(Vector128<int> value, [ConstantExpected] byte index) => Extract(value, index);
         /// <summary>
         /// int _mm_extract_epi32 (__m128i a, const int imm8)
         ///   PEXTRD reg/m32, xmm, imm8
         /// </summary>
-        public static uint Extract(Vector128<uint> value, byte index) => Extract(value, index);
+        public static uint Extract(Vector128<uint> value, [ConstantExpected] byte index) => Extract(value, index);
         /// <summary>
         /// int _mm_extract_ps (__m128 a, const int imm8)
         ///   EXTRACTPS xmm, xmm/m32, imm8
         /// </summary>
-        public static float Extract(Vector128<float> value, byte index) => Extract(value, index);
+        public static float Extract(Vector128<float> value, [ConstantExpected] byte index) => Extract(value, index);
 
         /// <summary>
         /// __m128 _mm_floor_ps (__m128 a)
@@ -370,27 +371,27 @@ internal X64() { }
         /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
         ///   PINSRB xmm, reg/m8, imm8
         /// </summary>
-        public static Vector128<sbyte> Insert(Vector128<sbyte> value, sbyte data, byte index) => Insert(value, data, index);
+        public static Vector128<sbyte> Insert(Vector128<sbyte> value, sbyte data, [ConstantExpected] byte index) => Insert(value, data, index);
         /// <summary>
         /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
         ///   PINSRB xmm, reg/m8, imm8
         /// </summary>
-        public static Vector128<byte> Insert(Vector128<byte> value, byte data, byte index) => Insert(value, data, index);
+        public static Vector128<byte> Insert(Vector128<byte> value, byte data, [ConstantExpected] byte index) => Insert(value, data, index);
         /// <summary>
         /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
         ///   PINSRD xmm, reg/m32, imm8
         /// </summary>
-        public static Vector128<int> Insert(Vector128<int> value, int data, byte index) => Insert(value, data, index);
+        public static Vector128<int> Insert(Vector128<int> value, int data, [ConstantExpected] byte index) => Insert(value, data, index);
         /// <summary>
         /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
         ///   PINSRD xmm, reg/m32, imm8
         /// </summary>
-        public static Vector128<uint> Insert(Vector128<uint> value, uint data, byte index) => Insert(value, data, index);
+        public static Vector128<uint> Insert(Vector128<uint> value, uint data, [ConstantExpected] byte index) => Insert(value, data, index);
         /// <summary>
         /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8)
         ///   INSERTPS xmm, xmm/m32, imm8
         /// </summary>
-        public static Vector128<float> Insert(Vector128<float> value, Vector128<float> data, byte index) => Insert(value, data, index);
+        public static Vector128<float> Insert(Vector128<float> value, Vector128<float> data, [ConstantExpected] byte index) => Insert(value, data, index);
 
         /// <summary>
         /// __m128i _mm_max_epi8 (__m128i a, __m128i b)
@@ -444,7 +445,7 @@ internal X64() { }
         /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8)
         ///   MPSADBW xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);
+        public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_mul_epi32 (__m128i a, __m128i b)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs
index 4129d8cf95d4f9..8ea7840fd6f0f7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 
@@ -44,55 +45,55 @@ internal X64() { }
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<short> AlignRight(Vector128<short> left, Vector128<short> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<short> AlignRight(Vector128<short> left, Vector128<short> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<ushort> AlignRight(Vector128<ushort> left, Vector128<ushort> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ushort> AlignRight(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<int> AlignRight(Vector128<int> left, Vector128<int> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<int> AlignRight(Vector128<int> left, Vector128<int> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<uint> AlignRight(Vector128<uint> left, Vector128<uint> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<uint> AlignRight(Vector128<uint> left, Vector128<uint> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<long> AlignRight(Vector128<long> left, Vector128<long> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<long> AlignRight(Vector128<long> left, Vector128<long> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<ulong> AlignRight(Vector128<ulong> left, Vector128<ulong> right, byte mask) { throw new PlatformNotSupportedException(); }
+        public static Vector128<ulong> AlignRight(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); }
 
         /// <summary>
         /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs
index 68d33bd1a3e330..5ea6532cc33890 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 namespace System.Runtime.Intrinsics.X86
@@ -44,56 +45,56 @@ internal X64() { }
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// </summary>
-        public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<short> AlignRight(Vector128<short> left, Vector128<short> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<short> AlignRight(Vector128<short> left, Vector128<short> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<ushort> AlignRight(Vector128<ushort> left, Vector128<ushort> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<ushort> AlignRight(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<int> AlignRight(Vector128<int> left, Vector128<int> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<int> AlignRight(Vector128<int> left, Vector128<int> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<uint> AlignRight(Vector128<uint> left, Vector128<uint> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<uint> AlignRight(Vector128<uint> left, Vector128<uint> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<long> AlignRight(Vector128<long> left, Vector128<long> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<long> AlignRight(Vector128<long> left, Vector128<long> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count)
         ///   PALIGNR xmm, xmm/m128, imm8
         /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors.
         /// </summary>
-        public static Vector128<ulong> AlignRight(Vector128<ulong> left, Vector128<ulong> right, byte mask) => AlignRight(left, right, mask);
+        public static Vector128<ulong> AlignRight(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
 
         /// <summary>
         /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b)
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 c3b1e9580c0890..c85b6a35cb93b6 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -1330,34 +1330,34 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<uint> ConvertToUInt32RoundToZeroScalar(System.Runtime.Intrinsics.Vector64<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<double> DivideScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<float> DivideScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<byte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<short> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<int> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<sbyte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<float> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<ushort> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<uint> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<byte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<short> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<int> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<sbyte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<float> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<ushort> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<uint> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<byte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<short> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<int> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<sbyte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<float> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<ushort> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<uint> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<byte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<short> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<int> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<sbyte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<float> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<ushort> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<uint> value, byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> DuplicateSelectedScalarToVector64(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> DuplicateToVector128(byte value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> DuplicateToVector128(short value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> DuplicateToVector128(int value) { throw null; }
@@ -1372,23 +1372,23 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<float> DuplicateToVector64(float value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ushort> DuplicateToVector64(ushort value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> DuplicateToVector64(uint value) { throw null; }
-        public static byte Extract(System.Runtime.Intrinsics.Vector128<byte> vector, byte index) { throw null; }
-        public static double Extract(System.Runtime.Intrinsics.Vector128<double> vector, byte index) { throw null; }
-        public static short Extract(System.Runtime.Intrinsics.Vector128<short> vector, byte index) { throw null; }
-        public static int Extract(System.Runtime.Intrinsics.Vector128<int> vector, byte index) { throw null; }
-        public static long Extract(System.Runtime.Intrinsics.Vector128<long> vector, byte index) { throw null; }
-        public static sbyte Extract(System.Runtime.Intrinsics.Vector128<sbyte> vector, byte index) { throw null; }
-        public static float Extract(System.Runtime.Intrinsics.Vector128<float> vector, byte index) { throw null; }
-        public static ushort Extract(System.Runtime.Intrinsics.Vector128<ushort> vector, byte index) { throw null; }
-        public static uint Extract(System.Runtime.Intrinsics.Vector128<uint> vector, byte index) { throw null; }
-        public static ulong Extract(System.Runtime.Intrinsics.Vector128<ulong> vector, byte index) { throw null; }
-        public static byte Extract(System.Runtime.Intrinsics.Vector64<byte> vector, byte index) { throw null; }
-        public static short Extract(System.Runtime.Intrinsics.Vector64<short> vector, byte index) { throw null; }
-        public static int Extract(System.Runtime.Intrinsics.Vector64<int> vector, byte index) { throw null; }
-        public static sbyte Extract(System.Runtime.Intrinsics.Vector64<sbyte> vector, byte index) { throw null; }
-        public static float Extract(System.Runtime.Intrinsics.Vector64<float> vector, byte index) { throw null; }
-        public static ushort Extract(System.Runtime.Intrinsics.Vector64<ushort> vector, byte index) { throw null; }
-        public static uint Extract(System.Runtime.Intrinsics.Vector64<uint> vector, byte index) { throw null; }
+        public static byte Extract(System.Runtime.Intrinsics.Vector128<byte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static double Extract(System.Runtime.Intrinsics.Vector128<double> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static short Extract(System.Runtime.Intrinsics.Vector128<short> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static int Extract(System.Runtime.Intrinsics.Vector128<int> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static long Extract(System.Runtime.Intrinsics.Vector128<long> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static sbyte Extract(System.Runtime.Intrinsics.Vector128<sbyte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static float Extract(System.Runtime.Intrinsics.Vector128<float> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static ushort Extract(System.Runtime.Intrinsics.Vector128<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static uint Extract(System.Runtime.Intrinsics.Vector128<uint> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static ulong Extract(System.Runtime.Intrinsics.Vector128<ulong> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static byte Extract(System.Runtime.Intrinsics.Vector64<byte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static short Extract(System.Runtime.Intrinsics.Vector64<short> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static int Extract(System.Runtime.Intrinsics.Vector64<int> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static sbyte Extract(System.Runtime.Intrinsics.Vector64<sbyte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static float Extract(System.Runtime.Intrinsics.Vector64<float> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static ushort Extract(System.Runtime.Intrinsics.Vector64<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static uint Extract(System.Runtime.Intrinsics.Vector64<uint> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<sbyte> ExtractNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<short> ExtractNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<int> ExtractNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
@@ -1419,23 +1419,23 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector128<sbyte> ExtractNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ushort> ExtractNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ExtractNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ExtractVector128(System.Runtime.Intrinsics.Vector128<byte> upper, System.Runtime.Intrinsics.Vector128<byte> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> ExtractVector128(System.Runtime.Intrinsics.Vector128<double> upper, System.Runtime.Intrinsics.Vector128<double> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ExtractVector128(System.Runtime.Intrinsics.Vector128<short> upper, System.Runtime.Intrinsics.Vector128<short> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ExtractVector128(System.Runtime.Intrinsics.Vector128<int> upper, System.Runtime.Intrinsics.Vector128<int> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ExtractVector128(System.Runtime.Intrinsics.Vector128<long> upper, System.Runtime.Intrinsics.Vector128<long> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ExtractVector128(System.Runtime.Intrinsics.Vector128<sbyte> upper, System.Runtime.Intrinsics.Vector128<sbyte> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> ExtractVector128(System.Runtime.Intrinsics.Vector128<float> upper, System.Runtime.Intrinsics.Vector128<float> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ExtractVector128(System.Runtime.Intrinsics.Vector128<ushort> upper, System.Runtime.Intrinsics.Vector128<ushort> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ExtractVector128(System.Runtime.Intrinsics.Vector128<uint> upper, System.Runtime.Intrinsics.Vector128<uint> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ExtractVector128(System.Runtime.Intrinsics.Vector128<ulong> upper, System.Runtime.Intrinsics.Vector128<ulong> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ExtractVector64(System.Runtime.Intrinsics.Vector64<byte> upper, System.Runtime.Intrinsics.Vector64<byte> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ExtractVector64(System.Runtime.Intrinsics.Vector64<short> upper, System.Runtime.Intrinsics.Vector64<short> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ExtractVector64(System.Runtime.Intrinsics.Vector64<int> upper, System.Runtime.Intrinsics.Vector64<int> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ExtractVector64(System.Runtime.Intrinsics.Vector64<sbyte> upper, System.Runtime.Intrinsics.Vector64<sbyte> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> ExtractVector64(System.Runtime.Intrinsics.Vector64<float> upper, System.Runtime.Intrinsics.Vector64<float> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ExtractVector64(System.Runtime.Intrinsics.Vector64<ushort> upper, System.Runtime.Intrinsics.Vector64<ushort> lower, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ExtractVector64(System.Runtime.Intrinsics.Vector64<uint> upper, System.Runtime.Intrinsics.Vector64<uint> lower, byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ExtractVector128(System.Runtime.Intrinsics.Vector128<byte> upper, System.Runtime.Intrinsics.Vector128<byte> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> ExtractVector128(System.Runtime.Intrinsics.Vector128<double> upper, System.Runtime.Intrinsics.Vector128<double> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ExtractVector128(System.Runtime.Intrinsics.Vector128<short> upper, System.Runtime.Intrinsics.Vector128<short> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ExtractVector128(System.Runtime.Intrinsics.Vector128<int> upper, System.Runtime.Intrinsics.Vector128<int> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ExtractVector128(System.Runtime.Intrinsics.Vector128<long> upper, System.Runtime.Intrinsics.Vector128<long> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ExtractVector128(System.Runtime.Intrinsics.Vector128<sbyte> upper, System.Runtime.Intrinsics.Vector128<sbyte> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> ExtractVector128(System.Runtime.Intrinsics.Vector128<float> upper, System.Runtime.Intrinsics.Vector128<float> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ExtractVector128(System.Runtime.Intrinsics.Vector128<ushort> upper, System.Runtime.Intrinsics.Vector128<ushort> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ExtractVector128(System.Runtime.Intrinsics.Vector128<uint> upper, System.Runtime.Intrinsics.Vector128<uint> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ExtractVector128(System.Runtime.Intrinsics.Vector128<ulong> upper, System.Runtime.Intrinsics.Vector128<ulong> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ExtractVector64(System.Runtime.Intrinsics.Vector64<byte> upper, System.Runtime.Intrinsics.Vector64<byte> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ExtractVector64(System.Runtime.Intrinsics.Vector64<short> upper, System.Runtime.Intrinsics.Vector64<short> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ExtractVector64(System.Runtime.Intrinsics.Vector64<int> upper, System.Runtime.Intrinsics.Vector64<int> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ExtractVector64(System.Runtime.Intrinsics.Vector64<sbyte> upper, System.Runtime.Intrinsics.Vector64<sbyte> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> ExtractVector64(System.Runtime.Intrinsics.Vector64<float> upper, System.Runtime.Intrinsics.Vector64<float> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ExtractVector64(System.Runtime.Intrinsics.Vector64<ushort> upper, System.Runtime.Intrinsics.Vector64<ushort> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ExtractVector64(System.Runtime.Intrinsics.Vector64<uint> upper, System.Runtime.Intrinsics.Vector64<uint> lower, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> Floor(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<float> Floor(System.Runtime.Intrinsics.Vector64<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<double> FloorScalar(System.Runtime.Intrinsics.Vector64<double> value) { throw null; }
@@ -1488,26 +1488,26 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<sbyte> FusedSubtractHalving(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ushort> FusedSubtractHalving(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> FusedSubtractHalving(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> vector, byte index, byte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> Insert(System.Runtime.Intrinsics.Vector128<double> vector, byte index, double data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> vector, byte index, short data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> vector, byte index, int data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> vector, byte index, long data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> Insert(System.Runtime.Intrinsics.Vector128<sbyte> vector, byte index, sbyte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> vector, byte index, float data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> vector, byte index, ushort data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> vector, byte index, uint data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> vector, byte index, ulong data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> Insert(System.Runtime.Intrinsics.Vector64<byte> vector, byte index, byte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> Insert(System.Runtime.Intrinsics.Vector64<short> vector, byte index, short data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> Insert(System.Runtime.Intrinsics.Vector64<int> vector, byte index, int data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> Insert(System.Runtime.Intrinsics.Vector64<sbyte> vector, byte index, sbyte data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> Insert(System.Runtime.Intrinsics.Vector64<float> vector, byte index, float data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> Insert(System.Runtime.Intrinsics.Vector64<ushort> vector, byte index, ushort data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> Insert(System.Runtime.Intrinsics.Vector64<uint> vector, byte index, uint data) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> InsertScalar(System.Runtime.Intrinsics.Vector128<double> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<double> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> InsertScalar(System.Runtime.Intrinsics.Vector128<long> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> InsertScalar(System.Runtime.Intrinsics.Vector128<ulong> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index, byte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Insert(System.Runtime.Intrinsics.Vector128<double> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, double data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, short data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, int data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, long data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Insert(System.Runtime.Intrinsics.Vector128<sbyte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index, sbyte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, float data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, ushort data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, uint data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, ulong data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> Insert(System.Runtime.Intrinsics.Vector64<byte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, byte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> Insert(System.Runtime.Intrinsics.Vector64<short> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, short data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> Insert(System.Runtime.Intrinsics.Vector64<int> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, int data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> Insert(System.Runtime.Intrinsics.Vector64<sbyte> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, sbyte data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> Insert(System.Runtime.Intrinsics.Vector64<float> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, float data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> Insert(System.Runtime.Intrinsics.Vector64<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, ushort data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> Insert(System.Runtime.Intrinsics.Vector64<uint> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, uint data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> InsertScalar(System.Runtime.Intrinsics.Vector128<double> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector64<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> InsertScalar(System.Runtime.Intrinsics.Vector128<long> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> InsertScalar(System.Runtime.Intrinsics.Vector128<ulong> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector64<ulong> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> LeadingSignCount(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> LeadingSignCount(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<sbyte> LeadingSignCount(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
@@ -1526,23 +1526,23 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<sbyte> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<sbyte> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ushort> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<ushort> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<uint> value) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<byte> value, byte index, byte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<double> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<double> value, byte index, double* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<short> value, byte index, short* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<int> value, byte index, int* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<long> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<long> value, byte index, long* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<sbyte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<sbyte> value, byte index, sbyte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<float> value, byte index, float* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ushort> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<ushort> value, byte index, ushort* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<uint> value, byte index, uint* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<ulong> value, byte index, ulong* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<byte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<byte> value, byte index, byte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<short> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<short> value, byte index, short* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<int> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<int> value, byte index, int* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<sbyte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, byte index, sbyte* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<float> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<float> value, byte index, float* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<ushort> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<ushort> value, byte index, ushort* address) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector64<uint> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<uint> value, byte index, uint* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index, byte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<double> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, double* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, short* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, int* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<long> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, long* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<sbyte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index, sbyte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, float* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ushort> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, ushort* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, uint* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, ulong* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<byte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, byte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<short> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, short* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<int> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, int* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<sbyte> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index, sbyte* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<float> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, float* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<ushort> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index, ushort* address) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector64<uint> LoadAndInsertScalar(System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index, uint* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadAndReplicateToVector128(byte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadAndReplicateToVector128(short* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<int> LoadAndReplicateToVector128(int* address) { throw null; }
@@ -1661,22 +1661,22 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<int> MultiplyAddByScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyAddByScalar(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> MultiplyAddByScalar(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> MultiplyByScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyByScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> MultiplyByScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
@@ -1687,86 +1687,86 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<float> MultiplyByScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyByScalar(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> MultiplyByScalar(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLower(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpper(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> MultiplyDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> MultiplyDoublingSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
@@ -1779,30 +1779,30 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerByScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateLower(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateLower(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateLowerByScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateLowerByScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateUpper(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateUpper(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateUpperByScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateUpperByScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
@@ -1811,34 +1811,34 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperByScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingByScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingSaturateHigh(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingSaturateHigh(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<double> MultiplyScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<float> MultiplyScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> MultiplyScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<float> MultiplyScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> MultiplyScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> MultiplyScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> MultiplySubtract(System.Runtime.Intrinsics.Vector128<byte> minuend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> MultiplySubtract(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplySubtract(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
@@ -1859,22 +1859,22 @@ internal AdvSimd() { }
         public static System.Runtime.Intrinsics.Vector64<int> MultiplySubtractByScalar(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<ushort> MultiplySubtractByScalar(System.Runtime.Intrinsics.Vector64<ushort> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> MultiplySubtractByScalar(System.Runtime.Intrinsics.Vector64<uint> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> minuend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> MultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<uint> minuend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningLower(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningLower(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningLower(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
@@ -2087,73 +2087,73 @@ 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, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturate(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateUnsigned(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftLeftLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalWideningLower(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogicalWideningUpper(System.Runtime.Intrinsics.Vector128<uint> value, byte 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<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<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<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<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<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<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<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<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; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftLogical(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
@@ -2218,190 +2218,190 @@ 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, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightAndInsert(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightAndInsertScalar(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right, byte shift) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticRoundedAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticRoundedScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightArithmeticScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<byte> addend, System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<long> addend, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<byte> addend, System.Runtime.Intrinsics.Vector64<byte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<sbyte> addend, System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<ushort> addend, System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedAdd(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalRoundedAddScalar(System.Runtime.Intrinsics.Vector64<ulong> addend, System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<byte> lower, System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<short> lower, System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<int> lower, System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<sbyte> lower, System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<ushort> lower, System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(System.Runtime.Intrinsics.Vector64<uint> lower, System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalRoundedScalar(System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<long> ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<ulong> ShiftRightLogicalScalar(System.Runtime.Intrinsics.Vector64<ulong> value, byte 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<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<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<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<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<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<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<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<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<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<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<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<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<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<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.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<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<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.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<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<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<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; }
@@ -2430,23 +2430,23 @@ public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector1
         public unsafe static void Store(uint* address, System.Runtime.Intrinsics.Vector64<uint> source) { }
         public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector128<ulong> source) { }
         public unsafe static void Store(ulong* address, System.Runtime.Intrinsics.Vector64<ulong> source) { }
-        public unsafe static void StoreSelectedScalar(byte* address, System.Runtime.Intrinsics.Vector128<byte> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(byte* address, System.Runtime.Intrinsics.Vector64<byte> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(double* address, System.Runtime.Intrinsics.Vector128<double> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(short* address, System.Runtime.Intrinsics.Vector128<short> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(short* address, System.Runtime.Intrinsics.Vector64<short> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(int* address, System.Runtime.Intrinsics.Vector128<int> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(int* address, System.Runtime.Intrinsics.Vector64<int> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(long* address, System.Runtime.Intrinsics.Vector128<long> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(sbyte* address, System.Runtime.Intrinsics.Vector128<sbyte> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(sbyte* address, System.Runtime.Intrinsics.Vector64<sbyte> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(float* address, System.Runtime.Intrinsics.Vector128<float> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(float* address, System.Runtime.Intrinsics.Vector64<float> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(ushort* address, System.Runtime.Intrinsics.Vector128<ushort> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(ushort* address, System.Runtime.Intrinsics.Vector64<ushort> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(uint* address, System.Runtime.Intrinsics.Vector128<uint> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(uint* address, System.Runtime.Intrinsics.Vector64<uint> value, byte index) { }
-        public unsafe static void StoreSelectedScalar(ulong* address, System.Runtime.Intrinsics.Vector128<ulong> value, byte index) { }
+        public unsafe static void StoreSelectedScalar(byte* address, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { }
+        public unsafe static void StoreSelectedScalar(byte* address, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { }
+        public unsafe static void StoreSelectedScalar(double* address, System.Runtime.Intrinsics.Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { }
+        public unsafe static void StoreSelectedScalar(short* address, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { }
+        public unsafe static void StoreSelectedScalar(short* address, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { }
+        public unsafe static void StoreSelectedScalar(int* address, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { }
+        public unsafe static void StoreSelectedScalar(int* address, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { }
+        public unsafe static void StoreSelectedScalar(long* address, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { }
+        public unsafe static void StoreSelectedScalar(sbyte* address, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { }
+        public unsafe static void StoreSelectedScalar(sbyte* address, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { }
+        public unsafe static void StoreSelectedScalar(float* address, System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { }
+        public unsafe static void StoreSelectedScalar(float* address, System.Runtime.Intrinsics.Vector64<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { }
+        public unsafe static void StoreSelectedScalar(ushort* address, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { }
+        public unsafe static void StoreSelectedScalar(ushort* address, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { }
+        public unsafe static void StoreSelectedScalar(uint* address, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { }
+        public unsafe static void StoreSelectedScalar(uint* address, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { }
+        public unsafe static void StoreSelectedScalar(ulong* address, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { }
         public static System.Runtime.Intrinsics.Vector128<byte> Subtract(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> Subtract(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> Subtract(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
@@ -2732,9 +2732,9 @@ internal Arm64() { }
             public static System.Runtime.Intrinsics.Vector128<double> Divide(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> Divide(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<float> Divide(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<double> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<double> value, byte index) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<long> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<long> value, byte index) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<ulong> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<ulong> value, byte index) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> DuplicateSelectedScalarToVector128(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> DuplicateToVector128(double value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<long> DuplicateToVector128(long value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<ulong> DuplicateToVector128(ulong value) { throw null; }
@@ -2752,57 +2752,57 @@ internal Arm64() { }
             public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAddByScalar(System.Runtime.Intrinsics.Vector128<double> addend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAddByScalar(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddByScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> addend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<double> FusedMultiplyAddScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> addend, System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> addend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> addend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<double> FusedMultiplyAddScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> addend, System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplyAddScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> addend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<double> minuend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtractByScalar(System.Runtime.Intrinsics.Vector128<double> minuend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtractByScalar(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractByScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> minuend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> minuend, System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<byte> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<byte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<byte> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<byte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<double> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<double> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<double> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<short> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<short> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<short> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<short> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<int> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<int> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<int> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<int> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<long> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<long> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<long> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<sbyte> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<sbyte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<sbyte> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<sbyte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<float> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<float> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<float> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<float> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<ushort> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<ushort> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<uint> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<uint> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<uint> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<uint> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<ulong> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<ulong> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<ulong> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<byte> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<byte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<byte> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<byte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<short> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<short> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<short> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<short> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<int> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<int> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<int> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<int> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<sbyte> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<sbyte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<sbyte> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<sbyte> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<float> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<float> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<float> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<float> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<ushort> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<ushort> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<uint> result, byte resultIndex, System.Runtime.Intrinsics.Vector128<uint> value, byte valueIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<uint> result, byte resultIndex, System.Runtime.Intrinsics.Vector64<uint> value, byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> minuend, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> minuend, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> minuend, System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> minuend, System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<byte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte resultIndex, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<byte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte resultIndex, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<double> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<short> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<short> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<int> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<int> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<long> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<sbyte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte resultIndex, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<sbyte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte resultIndex, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<float> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<float> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector64<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<ushort> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<uint> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<uint> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> InsertSelectedScalar(System.Runtime.Intrinsics.Vector128<ulong> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<byte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<byte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<byte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector64<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<short> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<short> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector64<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<int> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<int> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector64<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<sbyte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<sbyte> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<sbyte> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte resultIndex, System.Runtime.Intrinsics.Vector64<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<float> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<float> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector64<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<ushort> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<ushort> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte resultIndex, System.Runtime.Intrinsics.Vector64<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<uint> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte valueIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<uint> InsertSelectedScalar(System.Runtime.Intrinsics.Vector64<uint> result, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte resultIndex, System.Runtime.Intrinsics.Vector64<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte valueIndex) { throw null; }
             public unsafe static System.Runtime.Intrinsics.Vector128<double> LoadAndReplicateToVector128(double* address) { throw null; }
             public unsafe static System.Runtime.Intrinsics.Vector128<long> LoadAndReplicateToVector128(long* address) { throw null; }
             public unsafe static System.Runtime.Intrinsics.Vector128<ulong> LoadAndReplicateToVector128(ulong* address) { throw null; }
@@ -2916,52 +2916,52 @@ internal Arm64() { }
             public static System.Runtime.Intrinsics.Vector64<float> MinScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> Multiply(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> MultiplyByScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<double> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> MultiplyBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingSaturateHighScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingSaturateHighScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningAndAddSaturateScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningAndAddSaturateScalar(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningAndSubtractSaturateScalar(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningAndSubtractSaturateScalar(System.Runtime.Intrinsics.Vector64<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningSaturateScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningSaturateScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(System.Runtime.Intrinsics.Vector64<long> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(System.Runtime.Intrinsics.Vector64<long> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> MultiplyExtended(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<float> MultiplyExtended(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtended(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> MultiplyExtendedByScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<double> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<double> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<double> MultiplyExtendedScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<double> MultiplyExtendedScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<double> MultiplyExtendedScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<float> MultiplyExtendedScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingSaturateHighScalar(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingSaturateHighScalar(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<double> MultiplyScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<double> MultiplyScalarBySelectedScalar(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<double> Negate(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<long> Negate(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
             public static System.Runtime.Intrinsics.Vector128<long> NegateSaturate(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
@@ -2999,15 +2999,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, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<sbyte> value, byte 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> 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; }
@@ -3020,30 +3020,30 @@ 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, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<short> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<int> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<long> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ushort> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<uint> value, byte count) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(System.Runtime.Intrinsics.Vector64<ulong> value, 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)(32))] 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<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<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<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<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<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<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<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(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> 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<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.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; }
@@ -3279,14 +3279,14 @@ internal Dp() { }
         public static System.Runtime.Intrinsics.Vector128<uint> DotProduct(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<int> DotProduct(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<uint> DotProduct(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, byte rightScaledIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte rightScaledIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> DotProductBySelectedQuadruplet(System.Runtime.Intrinsics.Vector64<uint> addend, System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightScaledIndex) { throw null; }
         public new abstract partial class Arm64 : System.Runtime.Intrinsics.Arm.AdvSimd.Arm64
         {
             internal Arm64() { }
@@ -3306,22 +3306,22 @@ internal Rdm() { }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<short> minuend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector128<int> minuend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         public new abstract partial class Arm64 : System.Runtime.Intrinsics.Arm.AdvSimd.Arm64
         {
             internal Arm64() { }
@@ -3330,14 +3330,14 @@ internal Arm64() { }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingAndAddSaturateHighScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingAndSubtractSaturateHighScalar(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
             public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingAndSubtractSaturateHighScalar(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte rightIndex) { throw null; }
-            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<short> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(System.Runtime.Intrinsics.Vector64<int> addend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<short> minuend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte rightIndex) { throw null; }
+            public static System.Runtime.Intrinsics.Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(System.Runtime.Intrinsics.Vector64<int> minuend, System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte rightIndex) { throw null; }
         }
     }
     [System.CLSCompliantAttribute(false)]
@@ -3385,7 +3385,7 @@ internal Aes() { }
         public static System.Runtime.Intrinsics.Vector128<byte> Encrypt(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> roundKey) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> EncryptLast(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> roundKey) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> InverseMixColumns(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> KeygenAssist(System.Runtime.Intrinsics.Vector128<byte> value, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> KeygenAssist(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse2.X64
         {
             internal X64() { }
@@ -3405,8 +3405,8 @@ internal Avx() { }
         public static System.Runtime.Intrinsics.Vector256<float> And(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> AndNot(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> AndNot(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Blend(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Blend(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Blend(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Blend(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> BlendVariable(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, System.Runtime.Intrinsics.Vector256<double> mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> BlendVariable(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, System.Runtime.Intrinsics.Vector256<float> mask) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<float> BroadcastScalarToVector128(float* source) { throw null; }
@@ -3416,10 +3416,10 @@ internal Avx() { }
         public unsafe static System.Runtime.Intrinsics.Vector256<float> BroadcastVector128ToVector256(float* address) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> Ceiling(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> Ceiling(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> Compare(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Compare(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Compare(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Compare(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Compare(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = System.Runtime.Intrinsics.X86.FloatComparisonMode.UnorderedTrueSignaling)] System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Compare(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = System.Runtime.Intrinsics.X86.FloatComparisonMode.UnorderedTrueSignaling)] System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Compare(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = System.Runtime.Intrinsics.X86.FloatComparisonMode.UnorderedTrueSignaling)] System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Compare(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = System.Runtime.Intrinsics.X86.FloatComparisonMode.UnorderedTrueSignaling)] System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> CompareEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> CompareEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
@@ -3442,8 +3442,8 @@ internal Avx() { }
         public static System.Runtime.Intrinsics.Vector256<float> CompareNotLessThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> CompareOrdered(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> CompareOrdered(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> CompareScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> CompareScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> CompareScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = System.Runtime.Intrinsics.X86.FloatComparisonMode.UnorderedTrueSignaling)] System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> CompareScalar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = System.Runtime.Intrinsics.X86.FloatComparisonMode.UnorderedTrueSignaling)] System.Runtime.Intrinsics.X86.FloatComparisonMode mode) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> CompareUnordered(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> CompareUnordered(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ConvertToVector128Int32(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
@@ -3456,36 +3456,36 @@ internal Avx() { }
         public static System.Runtime.Intrinsics.Vector256<float> ConvertToVector256Single(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> Divide(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> Divide(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> DotProduct(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> DotProduct(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> DuplicateEvenIndexed(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> DuplicateEvenIndexed(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> DuplicateOddIndexed(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ExtractVector128(System.Runtime.Intrinsics.Vector256<byte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> ExtractVector128(System.Runtime.Intrinsics.Vector256<double> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ExtractVector128(System.Runtime.Intrinsics.Vector256<short> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ExtractVector128(System.Runtime.Intrinsics.Vector256<int> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ExtractVector128(System.Runtime.Intrinsics.Vector256<long> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ExtractVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> ExtractVector128(System.Runtime.Intrinsics.Vector256<float> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ExtractVector128(System.Runtime.Intrinsics.Vector256<ushort> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ExtractVector128(System.Runtime.Intrinsics.Vector256<uint> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ExtractVector128(System.Runtime.Intrinsics.Vector256<ulong> value, byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ExtractVector128(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> ExtractVector128(System.Runtime.Intrinsics.Vector256<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ExtractVector128(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ExtractVector128(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ExtractVector128(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ExtractVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> ExtractVector128(System.Runtime.Intrinsics.Vector256<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ExtractVector128(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ExtractVector128(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ExtractVector128(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> Floor(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> Floor(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> HorizontalAdd(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> HorizontalAdd(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> HorizontalSubtract(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> HorizontalSubtract(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> InsertVector128(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector128<byte> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> InsertVector128(System.Runtime.Intrinsics.Vector256<double> value, System.Runtime.Intrinsics.Vector128<double> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> InsertVector128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> InsertVector128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> InsertVector128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector128<long> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> InsertVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> InsertVector128(System.Runtime.Intrinsics.Vector256<float> value, System.Runtime.Intrinsics.Vector128<float> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> InsertVector128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> InsertVector128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector128<uint> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> InsertVector128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> data, byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> InsertVector128(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector128<byte> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> InsertVector128(System.Runtime.Intrinsics.Vector256<double> value, System.Runtime.Intrinsics.Vector128<double> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> InsertVector128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> InsertVector128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> InsertVector128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector128<long> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> InsertVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> InsertVector128(System.Runtime.Intrinsics.Vector256<float> value, System.Runtime.Intrinsics.Vector128<float> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> InsertVector128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> InsertVector128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector128<uint> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> InsertVector128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<byte> LoadAlignedVector256(byte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<double> LoadAlignedVector256(double* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<short> LoadAlignedVector256(short* address) { throw null; }
@@ -3532,20 +3532,20 @@ public unsafe static void MaskStore(float* address, System.Runtime.Intrinsics.Ve
         public static System.Runtime.Intrinsics.Vector256<float> Multiply(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> Or(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> Or(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> Permute(System.Runtime.Intrinsics.Vector128<double> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Permute(System.Runtime.Intrinsics.Vector128<float> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Permute(System.Runtime.Intrinsics.Vector256<double> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Permute(System.Runtime.Intrinsics.Vector256<float> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> Permute2x128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Permute2x128(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> Permute2x128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> Permute2x128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> Permute2x128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> Permute2x128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Permute2x128(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> Permute2x128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> Permute2x128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> Permute2x128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Permute(System.Runtime.Intrinsics.Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Permute(System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Permute(System.Runtime.Intrinsics.Vector256<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Permute(System.Runtime.Intrinsics.Vector256<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Permute2x128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Permute2x128(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Permute2x128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Permute2x128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Permute2x128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Permute2x128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Permute2x128(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Permute2x128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Permute2x128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Permute2x128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> PermuteVar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<long> control) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> PermuteVar(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<int> control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> PermuteVar(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<long> control) { throw null; }
@@ -3562,8 +3562,8 @@ public unsafe static void MaskStore(float* address, System.Runtime.Intrinsics.Ve
         public static System.Runtime.Intrinsics.Vector256<float> RoundToPositiveInfinity(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> RoundToZero(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> RoundToZero(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Shuffle(System.Runtime.Intrinsics.Vector256<double> value, System.Runtime.Intrinsics.Vector256<double> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<float> Shuffle(System.Runtime.Intrinsics.Vector256<float> value, System.Runtime.Intrinsics.Vector256<float> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Shuffle(System.Runtime.Intrinsics.Vector256<double> value, System.Runtime.Intrinsics.Vector256<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Shuffle(System.Runtime.Intrinsics.Vector256<float> value, System.Runtime.Intrinsics.Vector256<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<double> Sqrt(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> Sqrt(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
         public unsafe static void Store(byte* address, System.Runtime.Intrinsics.Vector256<byte> source) { }
@@ -3666,14 +3666,14 @@ internal Avx2() { }
         public static System.Runtime.Intrinsics.Vector256<short> AddSaturate(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ushort> AddSaturate(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> AlignRight(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> AlignRight(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> AlignRight(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> AlignRight(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> AlignRight(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> AlignRight(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> AlignRight(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> AlignRight(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AlignRight(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AlignRight(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AlignRight(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AlignRight(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> AlignRight(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AlignRight(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AlignRight(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AlignRight(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<byte> And(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> And(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> And(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
@@ -3692,12 +3692,12 @@ internal Avx2() { }
         public static System.Runtime.Intrinsics.Vector256<ulong> AndNot(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<byte> Average(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ushort> Average(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> Blend(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> Blend(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> Blend(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> Blend(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> Blend(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> Blend(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Blend(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Blend(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Blend(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Blend(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Blend(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Blend(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<byte> BlendVariable(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, System.Runtime.Intrinsics.Vector256<byte> mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> BlendVariable(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, System.Runtime.Intrinsics.Vector256<short> mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> BlendVariable(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, System.Runtime.Intrinsics.Vector256<int> mask) { throw null; }
@@ -3788,76 +3788,76 @@ internal Avx2() { }
         public unsafe static System.Runtime.Intrinsics.Vector256<long> ConvertToVector256Int64(sbyte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<long> ConvertToVector256Int64(ushort* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<long> ConvertToVector256Int64(uint* address) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<byte> ExtractVector128(System.Runtime.Intrinsics.Vector256<byte> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<short> ExtractVector128(System.Runtime.Intrinsics.Vector256<short> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<int> ExtractVector128(System.Runtime.Intrinsics.Vector256<int> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<long> ExtractVector128(System.Runtime.Intrinsics.Vector256<long> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<sbyte> ExtractVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<ushort> ExtractVector128(System.Runtime.Intrinsics.Vector256<ushort> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<uint> ExtractVector128(System.Runtime.Intrinsics.Vector256<uint> value, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector128<ulong> ExtractVector128(System.Runtime.Intrinsics.Vector256<ulong> value, byte index) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<double> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<double> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<int> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<int> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector128<int> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<long> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<long> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<float> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<float> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector128<float> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<uint> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<uint> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector128<uint> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<ulong> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<ulong> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector256<double> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector256<double> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<int> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, System.Runtime.Intrinsics.Vector256<int> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector256<long> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector256<long> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<float> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, System.Runtime.Intrinsics.Vector256<float> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<uint> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, System.Runtime.Intrinsics.Vector256<uint> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector256<ulong> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector256<ulong> mask, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherVector128(double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherVector128(double* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherVector128(int* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherVector128(int* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherVector128(int* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherVector128(long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherVector128(long* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherVector128(float* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherVector128(float* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherVector128(float* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherVector128(uint* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherVector128(uint* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherVector128(uint* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherVector128(ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherVector128(ulong* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherVector256(double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherVector256(double* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<int> GatherVector256(int* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherVector256(long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherVector256(long* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<float> GatherVector256(float* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<uint> GatherVector256(uint* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherVector256(ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, byte scale) { throw null; }
-        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherVector256(ulong* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, byte scale) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<byte> ExtractVector128(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<short> ExtractVector128(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<int> ExtractVector128(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<long> ExtractVector128(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<sbyte> ExtractVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<ushort> ExtractVector128(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<uint> ExtractVector128(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector128<ulong> ExtractVector128(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<double> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<double> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<int> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<int> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector128<int> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<long> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<long> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<float> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<float> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector128<float> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<uint> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<uint> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector128<uint> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector128<ulong> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherMaskVector128(System.Runtime.Intrinsics.Vector128<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, System.Runtime.Intrinsics.Vector128<ulong> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector256<double> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<double> source, double* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector256<double> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<int> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<int> source, int* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, System.Runtime.Intrinsics.Vector256<int> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector256<long> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<long> source, long* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector256<long> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<float> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<float> source, float* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, System.Runtime.Intrinsics.Vector256<float> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<uint> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<uint> source, uint* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, System.Runtime.Intrinsics.Vector256<uint> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, System.Runtime.Intrinsics.Vector256<ulong> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherMaskVector256(System.Runtime.Intrinsics.Vector256<ulong> source, ulong* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, System.Runtime.Intrinsics.Vector256<ulong> mask, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherVector128(double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<double> GatherVector128(double* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherVector128(int* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherVector128(int* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<int> GatherVector128(int* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherVector128(long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<long> GatherVector128(long* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherVector128(float* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherVector128(float* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<float> GatherVector128(float* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherVector128(uint* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherVector128(uint* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<uint> GatherVector128(uint* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherVector128(ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector128<ulong> GatherVector128(ulong* baseAddress, System.Runtime.Intrinsics.Vector128<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherVector256(double* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<double> GatherVector256(double* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<int> GatherVector256(int* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherVector256(long* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<long> GatherVector256(long* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<float> GatherVector256(float* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<uint> GatherVector256(uint* baseAddress, System.Runtime.Intrinsics.Vector256<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherVector256(ulong* baseAddress, System.Runtime.Intrinsics.Vector128<int> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
+        public unsafe static System.Runtime.Intrinsics.Vector256<ulong> GatherVector256(ulong* baseAddress, System.Runtime.Intrinsics.Vector256<long> index, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> HorizontalAdd(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> HorizontalAdd(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> HorizontalAddSaturate(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> HorizontalSubtract(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> HorizontalSubtract(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> HorizontalSubtractSaturate(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<byte> InsertVector128(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector128<byte> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<short> InsertVector128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<int> InsertVector128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<long> InsertVector128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector128<long> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<sbyte> InsertVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<ushort> InsertVector128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<uint> InsertVector128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector128<uint> data, byte index) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<ulong> InsertVector128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> data, byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<byte> InsertVector128(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector128<byte> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<short> InsertVector128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<int> InsertVector128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<long> InsertVector128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector128<long> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<sbyte> InsertVector128(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<ushort> InsertVector128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<uint> InsertVector128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector128<uint> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<ulong> InsertVector128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<byte> LoadAlignedVector256NonTemporal(byte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<short> LoadAlignedVector256NonTemporal(short* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector256<int> LoadAlignedVector256NonTemporal(int* address) { throw null; }
@@ -3896,7 +3896,7 @@ public unsafe static void MaskStore(ulong* address, System.Runtime.Intrinsics.Ve
         public static System.Runtime.Intrinsics.Vector256<uint> Min(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
         public static int MoveMask(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
         public static int MoveMask(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> MultipleSumAbsoluteDifferences(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultipleSumAbsoluteDifferences(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<long> Multiply(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ulong> Multiply(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> MultiplyAddAdjacent(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
@@ -3920,40 +3920,40 @@ public unsafe static void MaskStore(ulong* address, System.Runtime.Intrinsics.Ve
         public static System.Runtime.Intrinsics.Vector256<short> PackSignedSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<byte> PackUnsignedSaturate(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ushort> PackUnsignedSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<byte> Permute2x128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<short> Permute2x128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<int> Permute2x128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<long> Permute2x128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<sbyte> Permute2x128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<ushort> Permute2x128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<uint> Permute2x128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, byte control) { throw null; }
-        public static new System.Runtime.Intrinsics.Vector256<ulong> Permute2x128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<double> Permute4x64(System.Runtime.Intrinsics.Vector256<double> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> Permute4x64(System.Runtime.Intrinsics.Vector256<long> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> Permute4x64(System.Runtime.Intrinsics.Vector256<ulong> value, byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<byte> Permute2x128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<short> Permute2x128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<int> Permute2x128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<long> Permute2x128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<sbyte> Permute2x128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<ushort> Permute2x128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<uint> Permute2x128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static new System.Runtime.Intrinsics.Vector256<ulong> Permute2x128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Permute4x64(System.Runtime.Intrinsics.Vector256<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Permute4x64(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Permute4x64(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> PermuteVar8x32(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<float> PermuteVar8x32(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<int> control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<uint> PermuteVar8x32(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector128<long> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<byte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<short> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<int> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<long> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<sbyte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<ushort> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<uint> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<ulong> value, byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogicalVariable(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogicalVariable(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<ulong> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogicalVariable(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
@@ -3962,32 +3962,32 @@ public unsafe static void MaskStore(ulong* address, System.Runtime.Intrinsics.Ve
         public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogicalVariable(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<ulong> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogicalVariable(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogicalVariable(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticVariable(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticVariable(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<uint> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector128<long> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<byte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<short> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<int> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<long> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<sbyte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<ushort> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<uint> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<ulong> value, byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalVariable(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalVariable(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<ulong> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalVariable(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
@@ -3997,13 +3997,13 @@ public unsafe static void MaskStore(ulong* address, System.Runtime.Intrinsics.Ve
         public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalVariable(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalVariable(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> count) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<byte> Shuffle(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<int> Shuffle(System.Runtime.Intrinsics.Vector256<int> value, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Shuffle(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<sbyte> Shuffle(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<uint> Shuffle(System.Runtime.Intrinsics.Vector256<uint> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShuffleHigh(System.Runtime.Intrinsics.Vector256<short> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShuffleHigh(System.Runtime.Intrinsics.Vector256<ushort> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<short> ShuffleLow(System.Runtime.Intrinsics.Vector256<short> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector256<ushort> ShuffleLow(System.Runtime.Intrinsics.Vector256<ushort> value, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Shuffle(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShuffleHigh(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShuffleHigh(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShuffleLow(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShuffleLow(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<short> Sign(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<int> Sign(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<sbyte> Sign(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
@@ -4212,8 +4212,8 @@ public abstract partial class Pclmulqdq : System.Runtime.Intrinsics.X86.Sse2
     {
         internal Pclmulqdq() { }
         public static new bool IsSupported { get { throw null; } }
-        public static System.Runtime.Intrinsics.Vector128<long> CarrylessMultiply(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> CarrylessMultiply(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CarrylessMultiply(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> CarrylessMultiply(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public new abstract partial class X64 : System.Runtime.Intrinsics.X86.Sse2.X64
         {
             internal X64() { }
@@ -4309,7 +4309,7 @@ public unsafe static void PrefetchNonTemporal(void* address) { }
         public static System.Runtime.Intrinsics.Vector128<float> ReciprocalSqrt(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> ReciprocalSqrtScalar(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> ReciprocalSqrtScalar(System.Runtime.Intrinsics.Vector128<float> upper, System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Shuffle(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Shuffle(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> Sqrt(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> SqrtScalar(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> SqrtScalar(System.Runtime.Intrinsics.Vector128<float> upper, System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
@@ -4440,9 +4440,9 @@ internal Sse2() { }
         public static System.Runtime.Intrinsics.Vector128<float> ConvertToVector128Single(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> Divide(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> DivideScalar(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
-        public static ushort Extract(System.Runtime.Intrinsics.Vector128<ushort> value, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> value, short data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> value, ushort data, byte index) { throw null; }
+        public static ushort Extract(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> value, short data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> value, ushort data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadAlignedVector128(byte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<double> LoadAlignedVector128(double* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadAlignedVector128(short* address) { throw null; }
@@ -4506,57 +4506,57 @@ public static void MemoryFence() { }
         public static System.Runtime.Intrinsics.Vector128<sbyte> PackSignedSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> PackSignedSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> PackUnsignedSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<byte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<short> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<int> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<long> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<sbyte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<ushort> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<uint> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<ulong> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical128BitLane(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, byte count) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte count) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> count) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<byte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<short> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<int> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<long> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<sbyte> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<ushort> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<uint> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<ulong> value, byte numBytes) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> Shuffle(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> Shuffle(System.Runtime.Intrinsics.Vector128<int> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> Shuffle(System.Runtime.Intrinsics.Vector128<uint> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShuffleHigh(System.Runtime.Intrinsics.Vector128<short> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShuffleHigh(System.Runtime.Intrinsics.Vector128<ushort> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> ShuffleLow(System.Runtime.Intrinsics.Vector128<short> value, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> ShuffleLow(System.Runtime.Intrinsics.Vector128<ushort> value, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical128BitLane(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte numBytes) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Shuffle(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Shuffle(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Shuffle(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShuffleHigh(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShuffleHigh(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShuffleLow(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShuffleLow(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> Sqrt(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> SqrtScalar(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> SqrtScalar(System.Runtime.Intrinsics.Vector128<double> upper, System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
@@ -4687,10 +4687,10 @@ public abstract partial class Sse41 : System.Runtime.Intrinsics.X86.Ssse3
     {
         internal Sse41() { }
         public static new bool IsSupported { get { throw null; } }
-        public static System.Runtime.Intrinsics.Vector128<double> Blend(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> Blend(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Blend(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> Blend(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Blend(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Blend(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Blend(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Blend(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> BlendVariable(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, System.Runtime.Intrinsics.Vector128<byte> mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> BlendVariable(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.Vector128<double> mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> BlendVariable(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, System.Runtime.Intrinsics.Vector128<short> mask) { throw null; }
@@ -4733,23 +4733,23 @@ internal Sse41() { }
         public unsafe static System.Runtime.Intrinsics.Vector128<long> ConvertToVector128Int64(sbyte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<long> ConvertToVector128Int64(ushort* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<long> ConvertToVector128Int64(uint* address) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<double> DotProduct(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, byte control) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> DotProduct(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, byte control) { throw null; }
-        public static byte Extract(System.Runtime.Intrinsics.Vector128<byte> value, byte index) { throw null; }
-        public static int Extract(System.Runtime.Intrinsics.Vector128<int> value, byte index) { throw null; }
-        public static float Extract(System.Runtime.Intrinsics.Vector128<float> value, byte index) { throw null; }
-        public static uint Extract(System.Runtime.Intrinsics.Vector128<uint> value, byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> DotProduct(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> DotProduct(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte control) { throw null; }
+        public static byte Extract(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static int Extract(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static float Extract(System.Runtime.Intrinsics.Vector128<float> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static uint Extract(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> Floor(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> Floor(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> FloorScalar(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<double> FloorScalar(System.Runtime.Intrinsics.Vector128<double> upper, System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> FloorScalar(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<float> FloorScalar(System.Runtime.Intrinsics.Vector128<float> upper, System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> value, byte data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> value, int data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> Insert(System.Runtime.Intrinsics.Vector128<sbyte> value, sbyte data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> value, System.Runtime.Intrinsics.Vector128<float> data, byte index) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> value, uint data, byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> value, byte data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> value, int data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Insert(System.Runtime.Intrinsics.Vector128<sbyte> value, sbyte data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> value, System.Runtime.Intrinsics.Vector128<float> data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> value, uint data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<byte> LoadAlignedVector128NonTemporal(byte* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<short> LoadAlignedVector128NonTemporal(short* address) { throw null; }
         public unsafe static System.Runtime.Intrinsics.Vector128<int> LoadAlignedVector128NonTemporal(int* address) { throw null; }
@@ -4767,7 +4767,7 @@ internal Sse41() { }
         public static System.Runtime.Intrinsics.Vector128<ushort> Min(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> Min(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<ushort> MinHorizontal(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> MultipleSumAbsoluteDifferences(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultipleSumAbsoluteDifferences(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<long> Multiply(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> MultiplyLow(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> MultiplyLow(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
@@ -4830,10 +4830,10 @@ internal Sse41() { }
         {
             internal X64() { }
             public static new bool IsSupported { get { throw null; } }
-            public static long Extract(System.Runtime.Intrinsics.Vector128<long> value, byte index) { throw null; }
-            public static ulong Extract(System.Runtime.Intrinsics.Vector128<ulong> value, byte index) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> value, long data, byte index) { throw null; }
-            public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> value, ulong data, byte index) { throw null; }
+            public static long Extract(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+            public static ulong Extract(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> value, long data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
+            public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> value, ulong data, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte index) { throw null; }
         }
     }
     [System.CLSCompliantAttribute(false)]
@@ -4860,14 +4860,14 @@ internal Ssse3() { }
         public static System.Runtime.Intrinsics.Vector128<ushort> Abs(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<uint> Abs(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<byte> Abs(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<byte> AlignRight(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<short> AlignRight(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<int> AlignRight(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<long> AlignRight(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<sbyte> AlignRight(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ushort> AlignRight(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<uint> AlignRight(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte mask) { throw null; }
-        public static System.Runtime.Intrinsics.Vector128<ulong> AlignRight(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> AlignRight(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AlignRight(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AlignRight(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AlignRight(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> AlignRight(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AlignRight(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AlignRight(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AlignRight(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute] byte mask) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> HorizontalAdd(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<int> HorizontalAdd(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<short> HorizontalAddSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
@@ -4932,30 +4932,30 @@ public abstract partial class PackedSimd
         public static Vector128<double> Splat(double value) { throw null; }
         public static Vector128<nint>   Splat(nint   value) { throw null; }
         public static Vector128<nuint>  Splat(nuint  value) { throw null; }
-        public static int    ExtractLane(Vector128<sbyte>  value, byte index) { throw null; }    // takes ImmLaneIdx16
-        public static uint   ExtractLane(Vector128<byte>   value, byte index) { throw null; }    // takes ImmLaneIdx16
-        public static int    ExtractLane(Vector128<short>  value, byte index) { throw null; }    // takes ImmLaneIdx8
-        public static uint   ExtractLane(Vector128<ushort> value, byte index) { throw null; }    // takes ImmLaneIdx8
-        public static int    ExtractLane(Vector128<int>    value, byte index) { throw null; }    // takes ImmLaneIdx4
-        public static uint   ExtractLane(Vector128<uint>   value, byte index) { throw null; }    // takes ImmLaneIdx4
-        public static long   ExtractLane(Vector128<long>   value, byte index) { throw null; }    // takes ImmLaneIdx2
-        public static ulong  ExtractLane(Vector128<ulong>  value, byte index) { throw null; }    // takes ImmLaneIdx2
-        public static float  ExtractLane(Vector128<float>  value, byte index) { throw null; }    // takes ImmLaneIdx4
-        public static double ExtractLane(Vector128<double> value, byte index) { throw null; }    // takes ImmLaneIdx2
-        public static nint   ExtractLane(Vector128<nint>   value, byte index) { throw null; }
-        public static nuint  ExtractLane(Vector128<nuint>  value, byte index) { throw null; }
-        public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, byte imm, int    value) { throw null; }   // takes ImmLaneIdx16
-        public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, byte imm, uint   value) { throw null; }   // takes ImmLaneIdx16
-        public static Vector128<short>  ReplaceLane(Vector128<short>  vector, byte imm, int    value) { throw null; }   // takes ImmLaneIdx8
-        public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, byte imm, uint   value) { throw null; }   // takes ImmLaneIdx8
-        public static Vector128<int>    ReplaceLane(Vector128<int>    vector, byte imm, int    value) { throw null; }   // takes ImmLaneIdx4
-        public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, byte imm, uint   value) { throw null; }   // takes ImmLaneIdx4
-        public static Vector128<long>   ReplaceLane(Vector128<long>   vector, byte imm, long   value) { throw null; }   // takes ImmLaneIdx2
-        public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, byte imm, ulong  value) { throw null; }   // takes ImmLaneIdx2
-        public static Vector128<float>  ReplaceLane(Vector128<float>  vector, byte imm, float  value) { throw null; }   // takes ImmLaneIdx4
-        public static Vector128<double> ReplaceLane(Vector128<double> vector, byte imm, double value) { throw null; }   // takes ImmLaneIdx2
-        public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, byte imm, nint   value) { throw null; }
-        public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, byte imm, nuint  value) { throw null; }
+        public static int    ExtractLane(Vector128<sbyte>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }    // takes ImmLaneIdx16
+        public static uint   ExtractLane(Vector128<byte>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte index) { throw null; }    // takes ImmLaneIdx16
+        public static int    ExtractLane(Vector128<short>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }    // takes ImmLaneIdx8
+        public static uint   ExtractLane(Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte index) { throw null; }    // takes ImmLaneIdx8
+        public static int    ExtractLane(Vector128<int>    value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }    // takes ImmLaneIdx4
+        public static uint   ExtractLane(Vector128<uint>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }    // takes ImmLaneIdx4
+        public static long   ExtractLane(Vector128<long>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }    // takes ImmLaneIdx2
+        public static ulong  ExtractLane(Vector128<ulong>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }    // takes ImmLaneIdx2
+        public static float  ExtractLane(Vector128<float>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }    // takes ImmLaneIdx4
+        public static double ExtractLane(Vector128<double> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte index) { throw null; }    // takes ImmLaneIdx2
+        public static nint   ExtractLane(Vector128<nint>   value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static nuint  ExtractLane(Vector128<nuint>  value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte index) { throw null; }
+        public static Vector128<sbyte>  ReplaceLane(Vector128<sbyte>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte imm, int    value) { throw null; }   // takes ImmLaneIdx16
+        public static Vector128<byte>   ReplaceLane(Vector128<byte>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte imm, uint   value) { throw null; }   // takes ImmLaneIdx16
+        public static Vector128<short>  ReplaceLane(Vector128<short>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte imm, int    value) { throw null; }   // takes ImmLaneIdx8
+        public static Vector128<ushort> ReplaceLane(Vector128<ushort> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte imm, uint   value) { throw null; }   // takes ImmLaneIdx8
+        public static Vector128<int>    ReplaceLane(Vector128<int>    vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, int    value) { throw null; }   // takes ImmLaneIdx4
+        public static Vector128<int>    ReplaceLane(Vector128<uint>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, uint   value) { throw null; }   // takes ImmLaneIdx4
+        public static Vector128<long>   ReplaceLane(Vector128<long>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, long   value) { throw null; }   // takes ImmLaneIdx2
+        public static Vector128<ulong>  ReplaceLane(Vector128<ulong>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, ulong  value) { throw null; }   // takes ImmLaneIdx2
+        public static Vector128<float>  ReplaceLane(Vector128<float>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, float  value) { throw null; }   // takes ImmLaneIdx4
+        public static Vector128<double> ReplaceLane(Vector128<double> vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte imm, double value) { throw null; }   // takes ImmLaneIdx2
+        public static Vector128<nint>   ReplaceLane(Vector128<nint>   vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, nint   value) { throw null; }
+        public static Vector128<nuint>  ReplaceLane(Vector128<nuint>  vector, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte imm, nuint  value) { throw null; }
         public static Vector128<sbyte> Shuffle(Vector128<sbyte> lower, Vector128<sbyte> upper, Vector128<sbyte> indices) { throw null; }
         public static Vector128<byte>  Shuffle(Vector128<byte>  lower, Vector128<byte>  upper, Vector128<byte>  indices) { throw null; }
         public static Vector128<sbyte> Swizzle(Vector128<sbyte> vector, Vector128<sbyte> indices) { throw null; }