diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.PlatformNotSupported.cs
new file mode 100644
index 00000000000000..c0a10d7aa1ae1f
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.PlatformNotSupported.cs
@@ -0,0 +1,5731 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    /// <summary>
+    /// This class provides access to the LASX-256bits hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+    abstract class Lasx : Lsx
+    {
+        internal Lasx() { }
+
+        public static new bool IsSupported { [Intrinsic] get { return false; } }
+
+        /// <summary>
+        /// int8x32_t xvadd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvadd_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvadd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Add(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvadd_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvadd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvadd_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvadd_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Add(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvadd_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfadd_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFADD.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Add(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfadd_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Add(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsadd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsadd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsadd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsadd_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsadd_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSADD.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsadd_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSADD.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsadd_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSADD.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsadd_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSADD.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvhaddw_h_b(int3x32_t a, int3x32_t b)
+        ///   LASX: XVHADDW.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AddOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvhaddw_hu_bu(uint3x32_t a, uint3x32_t b)
+        ///   LASX: XVHADDW.HU.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AddOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvhaddw_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVHADDW.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> AddOddEvenElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvhaddw_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVHADDW.WU.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AddOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvhaddw_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVHADDW.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> AddOddEvenElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvhaddw_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVHADDW.DU.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AddOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvhaddw_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVHADDW.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddOddEvenElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvhaddw_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVHADDW.QU.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvaddwev_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWEV.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvaddwev_h_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVADDWEV.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> AddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvaddwev_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWEV.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddEvenElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvaddwev_w_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVADDWEV.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> AddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvaddwev_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWEV.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvaddwev_d_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVADDWEV.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> AddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvaddwev_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWEV.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvaddwev_q_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVADDWEV.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvaddwod_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddOddElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvaddwod_h_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVADDWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> AddOddElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvaddwod_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWOD.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddOddElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvaddwod_w_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVADDWOD.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> AddOddElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvaddwod_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWOD.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvaddwod_d_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVADDWOD.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> AddOddElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvaddwod_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWOD.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvaddwod_q_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVADDWOD.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddOddElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvaddwev_h_bu_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWEV.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddEvenElementsWidening(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvaddwev_w_hu_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWEV.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddEvenElementsWidening(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvaddwev_d_wu_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWEV.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvaddwev_q_du_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWEV.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvaddwod_h_bu_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWOD.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddOddElementsWidening(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvaddwod_w_hu_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWOD.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddOddElementsWidening(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvaddwod_d_wu_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWOD.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvaddwod_q_du_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWOD.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.HU.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.WU.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.DU.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.QU.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: sum_all_float_elements witin vector.
+        /// </summary>
+        public static Vector64<float> AddHorizontalElements(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: sum_all_double_elements witin vector.
+        /// </summary>
+        public static Vector64<double> AddHorizontalElements(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsub_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsub_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsub_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsub_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsub_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsub_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsub_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsub_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfsub_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFSUB.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfsub_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvhsubw_h_b(int3x32_t a, int3x32_t b)
+        ///   LASX: XVHSUBW.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> SubtractOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvhsubw_hu_bu(uint3x32_t a, uint3x32_t b)
+        ///   LASX: XVHSUBW.HU.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> SubtractOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvhsubw_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVHSUBW.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> SubtractOddEvenElementsWidening(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvhsubw_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVHSUBW.WU.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> SubtractOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvhsubw_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVHSUBW.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> SubtractOddEvenElementsWidening(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvhsubw_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVHSUBW.DU.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> SubtractOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvhsubw_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVHSUBW.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> SubtractOddEvenElementsWidening(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvhsubw_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVHSUBW.QU.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> SubtractOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvssub_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvssub_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSSUB.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssub_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssub_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSSUB.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvssub_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssub_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSSUB.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvssub_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> SubtractSaturate(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvssub_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSSUB.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> SubtractSaturate(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmul_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Multiply(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmul_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Multiply(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmul_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Multiply(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmul_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Multiply(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmul_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULW Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Multiply(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmul_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMUL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Multiply(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmul_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Multiply(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmul_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Multiply(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmul_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMUL.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmul_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmuh_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMUH.B Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<sbyte> MultiplyHight(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmuh_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMUH.BU Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<byte> MultiplyHight(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmuh_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMUH.H Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<short> MultiplyHight(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmuh_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMUH.HU Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<ushort> MultiplyHight(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmuh_w(int32x8_t a, int32x8_t b)
+        ///   LASX: VMUL.W Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<int> MultiplyHight(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmuh_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMUH.WU Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<uint> MultiplyHight(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmuh_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMUH.D Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyHight(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmuh_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMUH.DU Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyHight(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvdiv_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVDIV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Divide(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvdiv_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVDIV.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Divide(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvdiv_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVDIV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Divide(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvdiv_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVDIV.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Divide(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvdiv_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVDIV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Divide(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvdiv_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvdiv_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVDIV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Divide(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvdiv_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVDIV.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Divide(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfdiv_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFDIV.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfdiv_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFDIV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmod_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Modulo(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmod_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMOD.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Modulo(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmod_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Modulo(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmod_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMOD.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Modulo(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmod_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Modulo(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmod_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMOD.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Modulo(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmod_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Modulo(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmod_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMOD.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Modulo(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmadd_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplyAdd(Vector256<float> left, Vector256<float> right, Vector256<float> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmadd_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplyAdd(Vector256<double> left, Vector256<double> right, Vector256<double> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfnmadd_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFNMADD.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplyAddNegated(Vector256<float> left, Vector256<float> right, Vector256<float> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfnmadd_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFNMADD.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplyAddNegated(Vector256<double> left, Vector256<double> right, Vector256<double> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmadd_b(int8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B               //NOTE: The Vd is both input and output while input as addend.
+        /// </summary>
+        public static Vector256<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmadd_b(uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> MultiplyAdd(Vector256<byte> addend, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmadd_h(int16x16_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> MultiplyAdd(Vector256<short> addend, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmadd_h(uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> MultiplyAdd(Vector256<ushort> addend, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmadd_w(int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> MultiplyAdd(Vector256<int> addend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmadd_w(uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> MultiplyAdd(Vector256<uint> addend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmadd_d(int64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyAdd(Vector256<long> addend, Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmadd_d(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyAdd(Vector256<ulong> addend, Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmsub_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplySubtract(Vector256<float> left, Vector256<float> right, Vector256<float> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmsub_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplySubtract(Vector256<double> left, Vector256<double> right, Vector256<double> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfnmsub_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFNMSUB.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplySubtractNegated(Vector256<float> left, Vector256<float> right, Vector256<float> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfnmsub_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFNMSUB.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplySubtractNegated(Vector256<double> left, Vector256<double> right, Vector256<double> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmsub_b(int8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> MultiplySubtract(Vector256<sbyte> minuend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmsub_b(uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVMSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> MultiplySubtract(Vector256<byte> minuend, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmsub_h(int16x16_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> MultiplySubtract(Vector256<short> minuend, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmsub_h(uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> MultiplySubtract(Vector256<ushort> minuend, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmsub_w(int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> MultiplySubtract(Vector256<int> minuend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmsub_w(uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> MultiplySubtract(Vector256<uint> minuend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmsub_d(int64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplySubtract(Vector256<long> addend, Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmsub_d(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplySubtract(Vector256<ulong> addend, Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmaddwev_h_b(int16x16_t a, int8x8_t b, int8x8_t c)
+        ///   LASX: XVMADDWEV.H.B Xd.16H, Xj.8B, Xk.8B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningLowerAndAdd(Vector256<short> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmaddwev_h_bu(uint16x16_t a, uint8x8_t b, uint8x8_t c)
+        ///   LASX: XVMADDWEV.H.BU Xd.16H, Xj.8B, Xk.8B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningLowerAndAdd(Vector256<ushort> addend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmaddwev_w_h(int32x8_t a, int16x4_t b, int16x4_t c)
+        ///   LASX: XVMADDWEV.W.H Xd.8W, Xj.4H, Xk.4H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningLowerAndAdd(Vector256<int> addend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmaddwev_w_hu(uint32x8_t a, uint16x4_t b, uint16x4_t c)
+        ///   LASX: XVMADDWEV.W.HU Xd.8W, Xj.4H, Xk.4H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningLowerAndAdd(Vector256<uint> addend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmaddwev_d_w(int64x4_t a, int32x2_t b, int32x2_t c)
+        ///   LASX: XVMADDWEV.D.W Xd.4D, Xj.2S, Xk.2S
+        /// </summary>
+        public static Vector256<long> MultiplyWideningLowerAndAdd(Vector256<long> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmaddwev_d_wu(uint64x4_t a, uint32x2_t b, uint32x2_t c)
+        ///   LASX: XVMADDWEV.D.WU Xd.4D, Xj.2S, Xk.2S
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningLowerAndAdd(Vector256<ulong> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmaddwod_h_b(int16x16_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMADDWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningUpperAndAdd(Vector256<short> addend, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmaddwod_h_bu(uint16x16_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVMADDWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningUpperAndAdd(Vector256<ushort> addend, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmaddwod_w_h(int32x8_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMADDWOD.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningUpperAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmaddwod_w_hu(uint32x8_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMADDWOD.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningUpperAndAdd(Vector256<uint> addend, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmaddwod_d_w(int64x4_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADDWOD.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> MultiplyWideningUpperAndAdd(Vector256<long> addend, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmaddwod_d_wu(uint64x4_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMADDWOD.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningUpperAndAdd(Vector256<ulong> addend, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvmsknz_b(int8x32_t value)
+        ///   LASX: XVMSKNZ.B Vd.32B, Vj.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareNotEqualZeroEach128(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvmsknz_b(uint8x32_t value)
+        ///   LASX: XVMSKNZ.B Vd.32B, Vj.32B
+        /// </summary>
+        public static Vector256<byte> CompareNotEqualZeroEach128(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvseqi_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVSEQI.B Xd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvseqi_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSEQI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> CompareEqual(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvseqi_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSEQI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> CompareEqual(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvseqi_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSEQI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> CompareEqual(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvseq_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSEQ.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvseq_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSEQ.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvseq_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSEQ.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvseq_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSEQ.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvseq_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvseq_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvseq_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvseq_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_ceq_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CEQ.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_ceq_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvmskltz_b(int8x32_t value)
+        ///   LASX: XVMSKLTZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThanZeroEach128(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvmskltz_h(int16x16_t value)
+        ///   LASX: XVMSKLTZ.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> CompareLessThanZeroEach128(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvmskltz_w(int32x8_t value)
+        ///   LASX: XVMSKLTZ.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> CompareLessThanZeroEach128(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvmskltz_d(int64x4_t value)
+        ///   LASX: XVMSKLTZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThanZeroEach128(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvslti_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVSLTI.Bd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvslti_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSLTI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> CompareLessThan(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvslti_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSLTI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> CompareLessThan(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvslti_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSLTI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> CompareLessThan(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslt_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLT.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslt_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLT.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslt_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLT.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslt_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLT.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslt_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslt_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslt_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLT.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_clt_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLT.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_clt_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvslei_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVSLEI.Bd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvslei_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSLEI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvslei_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSLEI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvslei_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSLEI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsle_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsle_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsle_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsle_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslei_bu(uint8x32_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.BU Xd.32B, Xj.32B, ui5
+        /// </summary>
+        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslei_hu(uint16x16_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.HU Xd.16H, Xj.16H, ui5
+        /// </summary>
+        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslei_wu(uint32x8_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslei_du(uint64x4_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.DU Xd.4D, Xj.4D, ui5
+        /// </summary>
+        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsle_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsle_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsle_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLE.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_cle_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_cle_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsle_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsle_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsle_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsle_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsle_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsle_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsle_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLE.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_cle_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_cle_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvmskgez_b(int8x32_t value)
+        ///   LASX: XVMSKGEZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareGreaterThanOrEqualZeroEach128(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslt_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLT.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslt_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLT.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslt_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLT.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslt_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLT.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslt_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslt_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslt_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLT.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_clt_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLT.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_clt_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmaxi_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVMAXI.B Xd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> Max(Vector256<sbyte> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmaxi_bu(uint8x32_t a, int8_t si5)
+        ///   LASX: XVMAXI.BU Xd.32B, Xj.32B, ui5
+        /// </summary>
+        public static Vector256<byte> Max(Vector256<byte> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmaxi_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVMAXI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> Max(Vector256<short> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmaxi_hu(uint16x16_t a, int8_t si5)
+        ///   LASX: XVMAXI.HU Xd.16H, Xj.16H, ui5
+        /// </summary>
+        public static Vector256<ushort> Max(Vector256<ushort> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmaxi_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVMAXI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> Max(Vector256<int> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmaxi_wu(uint32x8_t a, int8_t si5)
+        ///   LASX: XVMAXI.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> Max(Vector256<uint> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmaxi_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVMAXI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> Max(Vector256<long> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmaxi_du(uint64x4_t a, int8_t si5)
+        ///   LASX: XVMAXI.DU Xd.4D, Xj.4D, ui5
+        /// </summary>
+        public static Vector256<ulong> Max(Vector256<ulong> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmax_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMAX.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmax_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMAX.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmax_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMAX.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Max(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmax_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMAX.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmax_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMAX.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmax_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMAX.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmax_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMAX.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmax_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMAX.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmax_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMAX.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmax_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMAX.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmaxa_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMAXA.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> MaxFloatAbsolute(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmaxa_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMAXA.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> MaxFloatAbsolute(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmini_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVMINI.B Xd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> Min(Vector256<sbyte> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmini_bu(uint8x32_t a, int8_t si5)
+        ///   LASX: XVMINI.BU Xd.32B, Xj.32B, ui5
+        /// </summary>
+        public static Vector256<byte> Min(Vector256<byte> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmini_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVMINI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> Min(Vector256<short> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmini_hu(uint16x16_t a, int8_t si5)
+        ///   LASX: XVMINI.HU Xd.16H, Xj.16H, ui5
+        /// </summary>
+        public static Vector256<ushort> Min(Vector256<ushort> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmini_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVMINI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> Min(Vector256<int> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmini_wu(uint32x8_t a, int8_t si5)
+        ///   LASX: XVMINI.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> Min(Vector256<uint> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmini_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVMINI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> Min(Vector256<long> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmini_du(uint64x4_t a, int8_t si5)
+        ///   LASX: XVMINI.DU Xd.4D, Xj.4D, ui5
+        /// </summary>
+        public static Vector256<ulong> Min(Vector256<ulong> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvmin_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMIN.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvmin_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMIN.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmin_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMIN.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmin_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMIN.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmin_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMIN.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmin_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMIN.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmin_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMIN.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmin_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMIN.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmin_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMIN.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmin_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMIN.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfmina_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMINA.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> MinFloatAbsolute(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfmina_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMINA.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> MinFloatAbsolute(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitsel_v(uint8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> BitwiseSelect(Vector256<sbyte> select, Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitsel_v(uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> BitwiseSelect(Vector256<byte> select, Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitsel_v(uint16x16_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> BitwiseSelect(Vector256<short> select, Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitsel_v(uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> BitwiseSelect(Vector256<ushort> select, Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvbitsel_v(uint32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> BitwiseSelect(Vector256<int> select, Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitsel_v(uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> BitwiseSelect(Vector256<uint> select, Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitsel_v(uint64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> BitwiseSelect(Vector256<long> select, Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitsel_v(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> BitwiseSelect(Vector256<ulong> select, Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvbitsel_v(uint32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> BitwiseSelect(Vector256<float> select, Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvbitsel_v(uint64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> BitwiseSelect(Vector256<double> select, Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvabsd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVABSD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AbsoluteDifference(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvabsd_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVABSD.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AbsoluteDifference(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvabsd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVABSD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AbsoluteDifference(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvabsd_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVABSD.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AbsoluteDifference(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvabsd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVABSD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvabsd_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVABSD.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvabsd_d(uint64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVABSD.D Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> AbsoluteDifference(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvabsd_du(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVABSD.DU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> AbsoluteDifference(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// float32x8_t TODO(float32x8_t a, float32x8_t b)   multi-instructions.
+        /////   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        ///// </summary>
+        //public static Vector256<float> AbsoluteDifference(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// float64x4_t TODO(float64x4_t a, float64x4_t b)
+        /////   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        ///// </summary>
+        //public static Vector256<double> AbsoluteDifference(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvld(int8_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvld(uint8_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<byte> LoadVector256(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvld(int16_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<short> LoadVector256(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvld(uint16_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadVector256(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvld(int32_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<int> LoadVector256(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvld(uint32_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<uint> LoadVector256(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvld(int64_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<long> LoadVector256(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvld(uint64_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadVector256(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvld(float32_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<float> LoadVector256(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvld(float64_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<double> LoadVector256(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvldx(int8_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvldx(uint8_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<byte> LoadVector256(byte* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvldx(int16_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<short> LoadVector256(short* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvldx(uint16_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadVector256(ushort* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvldx(int32_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<int> LoadVector256(int* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvldx(uint32_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<uint> LoadVector256(uint* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvldx(int64_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<long> LoadVector256(long* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvldx(uint64_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadVector256(ulong* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvldx(float32_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.8S, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<float> LoadVector256(float* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvldx(float64_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<double> LoadVector256(double* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvldrepl_b(int8_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.B Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadElementReplicateVector(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvldrepl_b(uint8_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.B Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<byte> LoadElementReplicateVector(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvldrepl_h(int16_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.H Xd.16H, Rj, si11
+        /// </summary>
+        public static unsafe Vector256<short> LoadElementReplicateVector(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvldrepl_h(uint16_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.H Xd.16H, Rj, si11
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadElementReplicateVector(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvldrepl_w(int32_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.W Xd.8W, Rj, si10
+        /// </summary>
+        public static unsafe Vector256<int> LoadElementReplicateVector(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvldrepl_w(uint32_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.W Xd.8W, Rj, si10
+        /// </summary>
+        public static unsafe Vector256<uint> LoadElementReplicateVector(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvldrepl_d(int64_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.D Xd.4D, Rj, si9
+        /// </summary>
+        public static unsafe Vector256<long> LoadElementReplicateVector(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvldrepl_d(uint64_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.D Xd.4D, Rj, si9
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadElementReplicateVector(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t vld(float32_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.W Xd.4S, Rj, si10
+        /// </summary>
+        public static unsafe Vector256<float> LoadElementReplicateVector(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvldrepl_d(float64_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.D Xd.4D, Rj, si9
+        /// </summary>
+        public static unsafe Vector256<double> LoadElementReplicateVector(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrecip_s(float32x8_t a)
+        ///   LASX: XVFRECIP.S Xd.8S Xj.8S
+        /// </summary>
+        public static Vector256<float> Reciprocal(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrecip_d(float64x4_t a)
+        ///   LASX: XVFRECIP.D Xd.4D Xj.4D
+        /// </summary>
+        public static Vector256<double> Reciprocal(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrsqrt_s(float32x8_t a)
+        ///   LASX: XVFRSQRT.S Xd.8S Xj.8S
+        /// </summary>
+        public static Vector256<float> ReciprocalSqrt(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrsqrt_d(float64x4_t a)
+        ///   LASX: XVFRSQRT.D Xd.4D Xj.4D
+        /// </summary>
+        public static Vector256<double> ReciprocalSqrt(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfsqrt_s(float32x8_t a)
+        ///   LASX: XVFSQRT.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Sqrt(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfsqrt_d(float64x4_t a)
+        ///   LASX: XVFSQRT.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Sqrt(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvflogb_d(float32x8_t a)
+        ///   LASX: XVFLOGB.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> FloatLogarithm2(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvflogb_d(float64x4_t a)
+        ///   LASX: XVFLOGB.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> FloatLogarithm2(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(int8x32_t val, int8_t* addr, const short si12)
+        ///   LASX: XVST Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(uint8x32_t val, uint8_t* addr, const short si12)
+        ///   LASX: XVST Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(int16x16_t val, int16_t* addr, const short si12)
+        ///   LASX: XVST Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(uint16x16_t val, uint16_t* addr, const short si12)
+        ///   LASX: XVST Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(int32x8_t val, int32_t* addr, const short si12)
+        ///   LASX: XVST Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(uint32x8_t val, uint32_t* addr, const short si12)
+        ///   LASX: XVST Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(int64x4_t val, int64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(uint64x4_t val, uint64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(float32x8_t val, float32_t* addr, const short si12)
+        ///   LASX: XVST Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvst(float64x4_t val, float64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(int8x32_t val, int8_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(uint8x32_t val, uint8_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<byte> vector, byte* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(int16x16_t val, int16_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<short> vector, short* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(uint16x16_t val, uint16_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(int32x8_t val, int32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<int> vector, int* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(uint32x8_t val, uint32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<uint> vector, uint* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(int64x4_t val, int64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<long> vector, long* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(uint64x4_t val, uint64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<ulong> vector, ulong* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(float32x8_t val, float32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<float> vector, float* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstx(float64x4_t val, float64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<double> vector, double* addr, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_b(int8x32_t val, int8_t* addr, const short si8, const byte idx)
+        ///   LASX: XVSTELM.B Xd.32B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(31))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_b(uint8x32_t val, uint8_t* addr, const short si8, const byte idx)
+        ///   LASX: XVSTELM.B Xd.32B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<byte> vector, byte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(31))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_h(int16x16_t val, int16_t* addr, const short si9, const byte idx) // Note: si9 is 2byte aligned.
+        ///   LASX: XVSTELM.H Xd.16H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<short> vector, short* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(15))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_h(uint16x16_t val, uint16_t* addr, const short si9, const byte idx)
+        ///   LASX: XVSTELM.H Xd.16H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<ushort> vector, ushort* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(15))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_w(int32x8_t val, int32_t* addr, const short si10, const byte idx) // Note: si10 is 4byte aligned.
+        ///   LASX: XVSTELM.W Xd.8W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<int> vector, int* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_w(uint32x8_t val, uint32_t* addr, const short si10, const byte idx)
+        ///   LASX: XVSTELM.W Xd.8W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<uint> vector, uint* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+ const      /// void xvstelm_d(int64x4_t val, int64_t* addr, const short si11, const byte idx) // Note: si11 is 8byte aligned.
+        ///   LASX: XVSTELM.D Xd.4D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<long> vector, long* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_d(uint64x4_t val, uint64_t* addr, const short si11, const byte idx)
+        ///   LASX: XVSTELM.D Xd.4D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<ulong> vector, ulong* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_w(float32x8_t val, float32_t* addr, const short si10, const byte idx)
+        ///   LASX: XVSTELM.W Xd.8S, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<float> vector, float* addr, [ConstantExpected(Min = -512, Max = 511)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void xvstelm_d(float64x4_t val, float64_t* addr, const short si11, const byte idx)
+        ///   LASX: XVSTELM.D Xd.4D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<double> vector, double* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvneg_b(int8x32_t a)
+        ///   LASX: XVNEG.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> Negate(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvneg_h(int16x16_t a)
+        ///   LASX: XVNEG.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> Negate(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvneg_w(int32x8_t a)
+        ///   LASX: XVNEG.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> Negate(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvneg_d(int64x4_t a)
+        ///   LASX: XVNEG.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> Negate(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvbitrevi_w(float32x8_t a)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, 31
+        /// </summary>
+        public static Vector256<float> Negate(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvbitrevi_d(float64x4_t a)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Negate(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmulwod_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningOdd(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmulwod_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMULWOD.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningOdd(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmulwod_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULWOD.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> MultiplyWideningOdd(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvmulwod_q_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMULWOD.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyWideningOdd(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvmulwev_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMULWEV.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningEven(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvmulwev_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMULWEV.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningEven(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvmulwev_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULWEV.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> MultiplyWideningEven(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvmulwev_q_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMULWEV.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyWideningEven(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmulwod_hu_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMULWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningOdd(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmulwod_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWOD.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningOdd(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmulwod_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningOdd(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvmulwod_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMULWOD.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningOdd(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvmulwev_hu_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMULWEV.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningEven(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvmulwev_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWEV.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningEven(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvmulwev_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWEV.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningEven(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvmulwev_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMULWEV.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningEven(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int16x16_t xvmulwod_h_bu(uint8x32_t a, int8x32_t b)
+        // ///   LASX: XVMULWOD.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        // /// </summary>
+        // public static Vector256<short> MultiplyWideningOdd(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int32x8_t xvmulwod_w_hu(uint16x16_t a, int16x16_t b)
+        // ///   LASX: XVMULWOD.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        // /// </summary>
+        // public static Vector256<int> MultiplyWideningOdd(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int64x4_t xvmulwod_d_wu(uint32x8_t a, int32x8_t b)
+        // ///   LASX: XVMULWOD.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningOdd(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int128x2_t xvmulwod_q_du(uint64x4_t a, int64x4_t b)
+        // ///   LASX: XVMULWOD.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningOdd(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int16x16_t xvmulwev_h_bu(uint8x32_t a, int8x32_t b)
+        // ///   LASX: XVMULWEV.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        // /// </summary>
+        // public static Vector256<short> MultiplyWideningEven(Vector256<byte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int32x8_t xvmulwev_w_hu(uint16x16_t a, int16x16_t b)
+        // ///   LASX: XVMULWEV.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        // /// </summary>
+        // public static Vector256<int> MultiplyWideningEven(Vector256<ushort> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int64x4_t xvmulwev_d_wu(uint32x8_t a, int32x8_t b)
+        // ///   LASX: XVMULWEV.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningEven(Vector256<uint> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int128x2_t xvmulwev_q_du(uint64x4_t a, int64x4_t b)
+        // ///   LASX: XVMULWEV.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningEven(Vector256<ulong> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvavg_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVAVG.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Average(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvavg_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVAVG.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvavg_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVAVG.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Average(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvavg_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVAVG.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvavg_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVAVG.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Average(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvavg_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAVG.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvavg_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVAVG.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Average(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvavg_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVAVG.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Average(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvavgr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVAVGR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AverageRounded(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvavgr_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVAVGR.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AverageRounded(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvavgr_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVAVGR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> AverageRounded(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvavgr_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVAVGR.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AverageRounded(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvavgr_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVAVGR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> AverageRounded(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvavgr_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAVGR.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AverageRounded(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvavgr_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVAVGR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AverageRounded(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvavgr_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVAVGR.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AverageRounded(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsllwil_h_b(int8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.H.B Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(Vector256<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsllwil_h_b(uint8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.H.B Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(Vector256<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsllwil_w_h(int16x4_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.W.H Xd.8W, Xj.4H, ui4
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(Vector256<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsllwil_w_h(uint16x4_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.W.H Xd.8W, Xj.4H, ui4
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(Vector256<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsllwil_d_w(int32x2_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.D.W Xd.4D, Xj.2W, ui5
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(Vector256<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsllwil_d_w(uint32x2_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.D.W Xd.4D, Xj.2W, ui5
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(Vector256<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsllwil_hu_bu(uint8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.HU.BU Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsllwil_hu_bu(int8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.HU.BU Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsllwil_wu_hu(uint16x16_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.WU.HU Xd.8W, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsllwil_wu_hu(int16x16_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.WU.HU Xd.8W, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsllwil_du_wu(uint32x8_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.DU.WU Xd.4D, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsllwil_du_wu(int32x8_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.DU.WU Xd.4D, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvextl_qu_du(int64x4_t a)
+        ///   LASX: XVEXTL.QU.DU Xd.2Q, Xj.D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLowerEach128(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvextl_qu_du(uint64x4_t a)
+        ///   LASX: XVEXTL.QU.DU Xd.2Q, Xj.D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLowerEach128(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t vext2xv_h_b(int8x16_t a)
+        ///   LASX: VEXT2XV.H.B Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLower(Vector128<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t vext2xv_h_b(uint8x16_t a)
+        ///   LASX: VEXT2XV.H.B Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLower(Vector128<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_b(int8x8_t a)
+        ///   LASX: VEXT2XV.W.B Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector64<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+        //public static Vector256<int> SignExtendWideningLower(Vector128<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_b(uint8x8_t a)
+        ///   LASX: VEXT2XV.W.B Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector64<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+        //public static Vector256<int> SignExtendWideningLower(Vector128<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_b(int8x4_t a)
+        ///   LASX: VEXT2XV.D.B Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_b(uint8x4_t a)
+        ///   LASX: VEXT2XV.D.B Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_h(int16x8_t a)
+        ///   LASX: VEXT2XV.W.H Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector128<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_h(uint16x8_t a)
+        ///   LASX: VEXT2XV.W.H Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector128<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_h(int16x4_t a)
+        ///   LASX: VEXT2XV.D.H Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+        //public static Vector256<long> SignExtendWideningLower(Vector128<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_h(uint16x4_t a)
+        ///   LASX: VEXT2XV.D.H Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+        //public static Vector256<long> SignExtendWideningLower(Vector128<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_w(int32x2_t a)
+        ///   LASX: VEXT2XV.D.W Xd.4D, Xj.2W
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector128<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_w(uint32x2_t a)
+        ///   LASX: VEXT2XV.D.W Xd.4D, Xj.2W
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector128<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t vext2xv_hu_bu(uint8x16_t a)
+        ///   LASX: VEXT2XV.HU.BU Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningLower(Vector128<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t vext2xv_hu_bu(int8x16_t a)
+        ///   LASX: VEXT2XV.HU.BU Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningLower(Vector128<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t vext2xv_wu_bu(uint8x8_t a)
+        ///   LASX: VEXT2XV.WU.BU Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningLower(Vector64<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vext2xv_wu_bu(int8x8_t a)
+        ///   LASX: VEXT2XV.WU.BU Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t vext2xv_du_bu(uint8x4_t a)
+        ///   LASX: VEXT2XV.DU.BU Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLower(Vector64<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_du_bu(int8x4_t a)
+        ///   LASX: VEXT2XV.DU.BU Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t vext2xv_wu_hu(uint16x8_t a)
+        ///   LASX: VEXT2XV.WU.HU Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningLower(Vector128<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vext2xv_wu_hu(int16x8_t a)
+        ///   LASX: VEXT2XV.WU.HU Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningLower(Vector128<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t vext2xv_du_hu(uint16x4_t a)
+        ///   LASX: VEXT2XV.DU.HU Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLower(Vector64<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_du_hu(int16x4_t a)
+        ///   LASX: VEXT2XV.DU.HU Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLower(Vector64<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t vext2xv_du_wu(uint32x4_t a)
+        ///   LASX: VEXT2XV.DU.WU Xd.4D, Xj.4W
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLower(Vector128<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vext2xv_du_wu(int32x4_t a)
+        ///   LASX: VEXT2XV.DU.WU Xd.4D, Xj.4W
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLower(Vector128<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvexth_h_b(int8x32_t a)
+        ///   LASX: XVEXTH.H.B Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningUpperEach128(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvexth_w_h(int16x16_t a)
+        ///   LASX: XVEXTH.W.H Xd.8W, Xj.16H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningUpperEach128(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvexth_d_w(int32x8_t a)
+        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8W
+        /// </summary>
+        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvexth_d_w(int64x4_t a)
+        ///   LASX: XVEXTH.Q.D Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvexth_HU_BU(int8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningUpperEach128(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvexth_HU_BU(uint8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningUpperEach128(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvexth_WU_HU(int16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8W, Xj.16H
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningUpperEach128(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvexth_WU_HU(uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8W, Xj.16H
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningUpperEach128(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvexth_DU_WU(uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8W
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningUpperEach128(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvexth_DU_WU(uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8W
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x2_t xvexth_DU_WU(int64x4_t a)
+        ///   LASX: XVEXTH.QU.DU Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x2_t xvexth_DU_WU(uint64x4_t a)
+        ///   LASX: XVEXTH.QU.DU Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvand_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvand_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvand_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> And(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvand_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvand_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> And(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvand_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvand_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> And(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvand_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvand_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> And(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvand_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> And(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvandn_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvandn_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvandn_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvandn_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvandn_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvandn_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvandn_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvandn_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvandn_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvandn_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvor_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvor_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvor_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvor_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvor_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvor_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvor_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvor_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvnori_b(uint8x32_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<byte> Not(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvnori_b(float64x4_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<double> Not(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvnori_b(int16x16_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<short> Not(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvnori_b(int32x8_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<int> Not(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvnori_b(int64x4_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<long> Not(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvnori_b(int8x32_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<sbyte> Not(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvnori_b(float32x8_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<float> Not(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvnori_b(uint16x16_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<ushort> Not(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvnori_b(uint32x8_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<uint> Not(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvnori_b(uint64x4_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
+        /// </summary>
+        public static Vector256<ulong> Not(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvnor_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVNOR.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<sbyte> NotOr(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvnor_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVNOR.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<byte> NotOr(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvnor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVNOR.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<short> NotOr(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvnor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVNOR.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<ushort> NotOr(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvnor_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVNOR.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<int> NotOr(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvnor_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVNOR.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<uint> NotOr(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvnor_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVNOR.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<long> NotOr(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvnor_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVNOR.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<ulong> NotOr(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvnor_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVNOR.V Vd.8S, Vj.8S, Vk.8S
+        /// </summary>
+        public static Vector256<float> NotOr(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvnor_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVNOR.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<double> NotOr(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t xvorn(uint8x8_t a, uint8x8_t b)
+        /// </summary>
+        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t xvorn(float64x1_t a, float64x1_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t xvorn(int16x4_t a, int16x4_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t xvorn(int32x2_t a, int32x2_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t xvorn(int64x1_t a, int64x1_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t xvorn(int8x8_t a, int8x8_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t xvorn(float32x2_t a, float32x2_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t xvorn(uint16x4_t a, uint16x4_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t xvorn(uint32x2_t a, uint32x2_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t xvorn(uint64x1_t a, uint64x1_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvorn_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<sbyte> OrNot(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvorn_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<byte> OrNot(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVORN.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<short> OrNot(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVORN.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<ushort> OrNot(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvorn_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVORN.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<int> OrNot(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvorn_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVORN.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<uint> OrNot(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvorn_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVORN.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<long> OrNot(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvorn_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVORN.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<ulong> OrNot(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvorn_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVORN.V Vd.8S, Vj.8S, Vk.8S
+        /// </summary>
+        public static Vector256<float> OrNot(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvorn_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVORN.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<double> OrNot(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvxor_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvxor_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvxor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvxor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvxor_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvxor_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvxor_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvxor_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvxor_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvxor_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvslli_b(int8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvslli_b(uint8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvslli_h(int16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvslli_h(uint16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvslli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvslli_d(int64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvslli_d(uint64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbsll_v(int8x32_t a, const int shift)
+        ///   LASX: XVBSLL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogicalByByteEach128(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbsll_v(uint8x32_t a, const int shift)
+        ///   LASX: XVBSLL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogicalByByteEach128(Vector256<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// int8x32_t xvsll_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, Vector256<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsll_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, Vector256<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16 xvsll_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSLL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16 xvsll_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSLL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8 xvsll_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSLL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8 xvsll_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSLL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4 xvsll_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSLL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4 xvsll_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSLL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbsrl_v(int8x32_t a, const int shift)
+        ///   LASX: XVBSRL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalByByteEach128(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbsrl_v(uint8x32_t a, const int shift)
+        ///   LASX: XVBSRL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalByByteEach128(Vector256<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// int8x32_t xvsrl_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSRL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, Vector256<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrl_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSRL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, Vector256<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16 xvsrl_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16 xvsrl_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8 xvsrl_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8 xvsrl_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4 xvsrl_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4 xvsrl_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrlr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSRLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, Vector256<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrlr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSRLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, Vector256<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16 xvsrlr_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16 xvsrlr_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8 xvsrlr_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8 xvsrlr_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4 xvsrlr_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4 xvsrlr_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsrlrni_b_h(uint16x16_t left, uint16x16_t right, const int n)
+        ///   LASX: XVSRLRNI.B.H Xd, Xj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrlrni_b_h(int16x16_t left, int16x16_t right, const int n)
+        ///   LASX: XVSRLRNI.B.H Xd, Xj, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsrlrni_h_w(int32x8_t left, int32x8_t right, const int n)
+        ///   LASX: XVSRLRNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsrlrni_h_w(uint32x8_t left, uint32x8_t right, const int n)
+        ///   LASX: XVSRLRNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsrlrni_w_d(int64x4_t left, int64x4_t right, const int n)
+        ///   LASX: XVSRLRNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsrlrni_w_d(uint64x4_t left, uint64x4_t right, const int n)
+        ///   LASX: XVSRLRNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x4_t xvsrlrni_d_q(int128x2_t left, int128x2_t right, const int n)
+        /////   LASX: XVSRLRNI.D.Q Xd, Xj, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvsrlrn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvsrlrn_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t xvsrlrn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t xvsrlrn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvsrlrn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvsrlrn_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvsrarni_b_h(int16x16_t left, int16x16_t right, const int n)
+        ///   LASX: XVSRARNI.B.H Xd, Xj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsrarni_h_w(int32x8_t left, int32x8_t right, const int n)
+        ///   LASX: XVSRARNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsrarni_w_d(int64x4_t left, int64x4_t right, const int n)
+        ///   LASX: XVSRARNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x4_t xvsrarni_d_q(int128x2_t left, int128x2_t right, const int n)
+        /////   LASX: XVSRARNI.D.Q Xd, Xj, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvsrarn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRARN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t xvsrarn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRARN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t xvsrarn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRARN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvsrarn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRARN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrai_b(int8x32_t a, const int n)
+        ///   LASX: XVSRAI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsrai_h(int16x16_t a, const int n)
+        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsrai_w(int32x8_t a, const int n)
+        ///   LASX: XVSRAI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsrai_d(int64x4_t a, const int n)
+        ///   LASX: XVSRAI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_txvsra_b(int8x32_t a, int8x32_t b)
+        ///   LASX:  XVSRA.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, Vector256<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16xvsra_h(int16x16_t value, int16x16_t shift)
+        ///   LASX:  XVSRA.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8xvsra_w(int32x8_t value, int32x8_t shift)
+        ///   LASX:  XVSRA.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4xvsra_d(int64x4_t value, int64x4_t shift)
+        ///   LASX:  XVSRA.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrari_b(int8x32_t a, const int n)
+        ///   LASX: XVSRARI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsrari_h(int16x16_t a, const int n)
+        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsrari_w(int32x8_t a, const int n)
+        ///   LASX: XVSRARI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsrari_d(int64x4_t a, const int n)
+        ///   LASX: XVSRARI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsrar_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSRAR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, Vector256<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16 xvsrar_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRAR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8 xvsrar_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRAR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4 xvsrar_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRAR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvrotri_b(uint8x32_t a, const int n)
+        ///   LASX: XVROTRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> RotateRight(Vector256<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvrotri_b(uint8x32_t a, const int n)
+        ///   LASX: XVROTRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> RotateRight(Vector256<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvrotri_h(uint16x16_t a, const int n)
+        ///   LASX: XVROTRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> RotateRight(Vector256<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvrotri_h(uint16x16_t a, const int n)
+        ///   LASX: XVROTRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> RotateRight(Vector256<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvrotri_w(uint32x8_t a, const int n)
+        ///   LASX: XVROTRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> RotateRight(Vector256<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvrotri_w(uint32x8_t a, const int n)
+        ///   LASX: XVROTRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> RotateRight(Vector256<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvrotri_d(uint64x4_t a, const int n)
+        ///   LASX: XVROTRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> RotateRight(Vector256<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvrotri_d(uint64x4_t a, const int n)
+        ///   LASX: XVROTRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> RotateRight(Vector256<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvrotr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVROTR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> RotateRight(Vector256<sbyte> value, Vector256<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvrotr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVROTR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> RotateRight(Vector256<byte> value, Vector256<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16 xvrotr_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVROTR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> RotateRight(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16 xvrotr_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVROTR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> RotateRight(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8 xvrotr_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVROTR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> RotateRight(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8 xvrotr_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVROTR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> RotateRight(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4 xvrotr_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVROTR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> RotateRight(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4 xvrotr_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVROTR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> RotateRight(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsigncov_b(int8x32_t a)
+        ///   LASX: XVSIGNCOV.B Xd.32B, Xj.32B, Xj.32B
+        /// </summary>
+        public static Vector256<byte> Abs(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsigncov_h(int16x16_t a)
+        ///   LASX: XVSIGNCOV.H Xd.16H, Xj.16H, Xj.16H
+        /// </summary>
+        public static Vector256<ushort> Abs(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsigncov_w(int32x8_t a)
+        ///   LASX: XVSIGNCOV.W Xd.8W, Xj.8W, Xj.8W
+        /// </summary>
+        public static Vector256<uint> Abs(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsigncov_d(int64xx_t a)
+        ///   LASX: XVSIGNCOV.D Xd.4D, Xj.4D, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> Abs(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvbitclri_w(float32x8_t a)
+        ///   LASX: XVBITCLRI.W Xd.8S, Xd.8S, 31
+        /// </summary>
+        public static Vector256<float> Abs(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvbitclri_d(float64x4_t a)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, 63
+        /// </summary>
+        public static Vector256<double> Abs(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrintrm_s(float32x8_t a)
+        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Floor(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrintrm_d(float64x4_t a)
+        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Floor(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrintrp_s(float32x8_t a)
+        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Ceiling(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrintrp_d(float64x4_t a)
+        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Ceiling(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrintrz_s(float32x8_t a)
+        ///   LASX: XVFRINTRZ.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> RoundToZero(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrintrz_d(float64x4_t a)
+        ///   LASX: XVFRINTRZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToZero(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrintrm_s(float32x8_t a)
+        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrintrm_d(float64x4_t a)
+        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvfrintrp_s(float32x8_t a)
+        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvfrintrp_d(float64x4_t a)
+        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvinsgr2vr_w(int32x8_t v, int32_t data, const int index)
+        ///   LASX: XVINSGR2VR.W Xd.S, Rj, ui3
+        /// </summary>
+        public static Vector256<int> Insert(Vector256<int> vector, int data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvinsgr2vr_w(uint32x8_t v, uint32_t data, const int index)
+        ///   LASX: XVINSGR2VR.W Xd.S, Rj, ui3
+        /// </summary>
+        public static Vector256<uint> Insert(Vector256<uint> vector, uint data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvinsgr2vr_d(int64x4_t v, int64_t data, const int index)
+        ///   LASX: XVINSGR2VR.D Xd.D, Rj, ui2
+        /// </summary>
+        public static Vector256<long> Insert(Vector256<long> vector, long data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvinsgr2vr_d(uint64x4_t v, uint64_t data, const int index)
+        ///   LASX: XVINSGR2VR.D Xd.D, Rj, ui2
+        /// </summary>
+        public static Vector256<ulong> Insert(Vector256<ulong> vector, ulong data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvinsve0_w(float32x8_t v, float32_t data, const int index)
+        ///   LASX: XVINSVE0.W Xd.S, Xj.S[0], ui3
+        /// </summary>
+        public static Vector256<float> Insert(Vector256<float> vector, float data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvinsve0_d(float64x4_t v, float64_t data, const int index)
+        ///   LASX: XVINSVE0.D Xd.D, Xj.D[0], ui2
+        /// </summary>
+        public static Vector256<double> Insert(Vector256<double> vector, double data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvreplgr2vr_b(int8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// </summary>
+        public static Vector256<sbyte> DuplicateToVector256(sbyte value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvreplgr2vr_b(uint8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// </summary>
+        public static Vector256<byte> DuplicateToVector256(byte value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvreplgr2vr_h(int16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// </summary>
+        public static Vector256<short> DuplicateToVector256(short value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvreplgr2vr_h(uint16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// </summary>
+        public static Vector256<ushort> DuplicateToVector256(ushort value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvreplgr2vr_w(int32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8W, Rj
+        /// </summary>
+        public static Vector256<int> DuplicateToVector256(int value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvreplgr2vr_w(uint32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8W, Rj
+        /// </summary>
+        public static Vector256<uint> DuplicateToVector256(uint value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvreplgr2vr_d(int64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// </summary>
+        public static Vector256<long> DuplicateToVector256(long value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvreplgr2vr_d(uint64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// </summary>
+        public static Vector256<ulong> DuplicateToVector256(ulong value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvreplve0_w(float32_t value)
+        ///   LASX: XVREPLVE0.W Xd.8S, Xj.S[0]
+        /// </summary>
+        public static Vector256<float> DuplicateToVector256(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvreplve0_d(float64_t value)
+        ///   LASX: XVREPLVE0.D Xd.4D, Xj.D[0]
+        /// </summary>
+        public static Vector256<double> DuplicateToVector256(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvffint_s_w(int32x8_t a)
+        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8W
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x8_t xvffint_s_wu(uint32x8_t a)
+        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8W
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvffint_d_l(int64x4_t a)
+        ///   LASX: XVFFINT.D.L Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> ConvertToDouble(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x4_t xvffint_d_lu(uint64x4_t a)
+        ///   LASX: XVFFINT.D.LU Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> ConvertToDouble(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetnez_v(uint8x32_t value)
+        ///   LASX: XVSETNEZ.V cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvseteqz_v(uint8x32_t value)
+        ///   LASX: XVSETEQZ.V cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_b(int8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_b(uint8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_h(int16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_h(uint16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w(int32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w(uint32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w(int64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetallnez_w(uint64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_b(int8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_b(uint8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_h(int16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_h(uint16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(int32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(uint32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(int64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(uint64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32 xvsrlni_b_h(int16x16_t left, int16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32 xvsrlni_b_h(uint16x16_t left, uint16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16 xvsrlni_h_w(int32x8_t left, int32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16 xvsrlni_h_w(uint32x8_t left, uint32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8 xvsrlni_w_d(int64x4_t left, int64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8 xvsrlni_w_d(uint64x4_t left, uint64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> left, Vector256<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x4 xvsrlni_d_q(uint128x2_t left, uint128x2_t right, shift)
+        /////   LASX: XVSRLNI.D.Q Xd.2Q, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvsrln_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLN.B.H Xd.8B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t xvsrln_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t xvsrln_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvsrln_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLN.W.D Xd.4W, Xj.4D, Xk.2D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvsrln_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLN.W.D Xd.4W, Xj.4D, Xk.2D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvssrlni_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRLNI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrlni_b_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLNI.B.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssrlni_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRLNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlni_h_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvssrlni_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRLNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrlni_w_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x4_t xvssrlni_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRLNI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvssrln_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRLN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvssrln_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t xvssrln_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t xvssrln_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvssrln_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRLN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvssrln_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlni_bu_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLNI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlni_hu_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLNI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrlni_wu_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLNI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x4_t xvssrlni_du_q(uint128x2_t left, uint128x2_t right, const byte n)
+        /////   LASX: XVSSRLNI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvssrln_bu_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t xvssrln_hu_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvssrln_wu_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssran_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRANI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssran_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRANI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvssran_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRANI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x4_t xvssran_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRANI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvssran_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRAN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t xvssran_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRAN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvssran_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRAN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrani_bu_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRANI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrani_hu_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRANI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrani_wu_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRANI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x4_t xvssrani_du_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRANI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvssran_bu_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRAN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t xvssran_hu_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRAN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvssran_wu_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRAN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssrlrni_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRLRNI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_b_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLRNI.B.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssrlrni_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRLRNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_h_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLRNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvssrlrni_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRLRNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrlrni_w_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLRNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x4_t xvssrlrni_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRLRNI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvssrlrn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvssrlrn_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t xvssrlrn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t xvssrlrn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvssrlrn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvssrlrn_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_bu_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLRNI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_hu_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLRNI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrlrni_wu_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLRNI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x4_t xvssrlrni_du_q(uint128x2_t left, uint128x2_t right, const byte n)
+        /////   LASX: XVSSRLRNI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvssrlrn_bu_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLRN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t xvssrlrn_hu_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLRN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvssrlrn_wu_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLRN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssrarn_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRARNI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvssrarn_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRARNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvssrarn_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRARNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x4_t xvssrarn_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRARNI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t xvssrarn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRARN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t xvssrarn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRARN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t xvssrarn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRARN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrarni_bu_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRARNI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvssrarni_hu_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRARNI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvssrarni_wu_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRARNI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x4_t xvssrarni_du_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRARNI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t xvssrarn_bu_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRARN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t xvssrarn_hu_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRARN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t xvssrarn_wu_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRARN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvclo_b(int8x32_t a)
+        ///   LASX: XVCLO.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> LeadingSignCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvclo_h(int16x16_t a)
+        ///   LASX: XVCLO.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> LeadingSignCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvclo_w(int32x8_t a)
+        ///   LASX: XVCLO.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> LeadingSignCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvclo_d(int64x4_t a)
+        ///   LASX: XVCLO.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> LeadingSignCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvclz_b(int8x32_t a)
+        ///   LASX: XVCLZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> LeadingZeroCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvclz_b(uint8x32_t a)
+        ///   LASX: XVCLZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<byte> LeadingZeroCount(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvclz_h(int16x16_t a)
+        ///   LASX: XVCLZ.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> LeadingZeroCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvclz_h(uint16x16_t a)
+        ///   LASX: XVCLZ.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<ushort> LeadingZeroCount(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvclz_w(int32x8_t a)
+        ///   LASX: XVCLZ.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> LeadingZeroCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvclz_w(uint32x8_t a)
+        ///   LASX: XVCLZ.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<uint> LeadingZeroCount(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvclz_d(int64x4_t a)
+        ///   LASX: XVCLZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> LeadingZeroCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvclz_d(uint64x4_t a)
+        ///   LASX: XVCLZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvpcnt_b(int8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvpcnt_b(uint8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<byte> PopCount(Vector256<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvpcnt_h(int16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<short> PopCount(Vector256<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvpcnt_h(uint16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<ushort> PopCount(Vector256<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvpcnt_w(int32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<int> PopCount(Vector256<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvpcnt_w(uint32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<uint> PopCount(Vector256<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvpcnt_d(int64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<long> PopCount(Vector256<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvpcnt_d(uint64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<ulong> PopCount(Vector256<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvperm_w(int32x8_t vec, int32x8_t idx)
+        ///   LASX: XVPERM.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorShuffle(Vector256<int> vector, Vector256<int> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvperm_w(uint32x8_t vec, uint32x8_t idx)
+        ///   LASX: XVPERM.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorShuffle(Vector256<uint> vector, Vector256<uint> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvpermi_w(int64x4_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector256<long> VectorShuffle(Vector256<long> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvpermi_w(uint64x4_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector256<ulong> VectorShuffle(Vector256<ulong> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int128x2_t xvpermi_w(int128x2_t vec0, int128x2_t vec1, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.2Q, Xj.2Q, ui8                    ///NOTE: The Xd is both input and output.
+        /// </summary>
+        public static Vector256<long> VectorShuffle(Vector256<long> vector0, Vector256<long> vector1, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        /////  uint8x32_t xvshuf_b(uint8x32_t vec, uint8x32_t idx)
+        /////   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        ///// </summary>
+        //public static Vector256<byte> VectorShuffleEach128(Vector256<byte> vector, Vector256<byte> indexs) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        /////  int8x32_t xvshuf_b(int8x32_t vec, int8x32_t idx)
+        /////   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        ///// </summary>
+        //public static Vector256<sbyte> VectorShuffleEach128(Vector256<sbyte> vector, Vector256<sbyte> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvshuf_b(uint8x32_t vec0, uint8x32_t vec1, uint8x32_t idx)
+        ///   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        /// </summary>
+        public static Vector256<byte> VectorShuffleEach128(Vector256<byte> vector0, Vector256<byte> vector1, Vector256<byte> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvshuf_b(int8x32_t vec0, int8x32_t vec1, int8x32_t idx)
+        ///   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorShuffleEach128(Vector256<sbyte> vector0, Vector256<sbyte> vector1, Vector256<sbyte> indexs) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        /////  int16x16_t xvshuf_h(int16x16_t vec, int16x16_t idx)
+        /////   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H                //NOTE: Xd is both input and output while input as index.
+        ///// </summary>
+        //public static Vector256<short> VectorShuffleEach128(Vector256<short> vector, Vector256<short> indexs) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        /////  uint16x16_t xvshuf_h(uint16x16_t vec, uint16x16_t idx)
+        /////   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H                                //NOTE: Xd is both input and output while input as index.
+        ///// </summary>
+        //public static Vector256<ushort> VectorShuffleEach128(Vector256<ushort> vector, Vector256<ushort> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvshuf_h(int16x16_t vec0, int16x16_t vec1, int16x16_t idx)
+        ///   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H                                //NOTE: Xd is both input and output while input as index.
+        /// </summary>
+        public static Vector256<short> VectorShuffleEach128(Vector256<short> vector0, Vector256<short> vector1, Vector256<short> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvshuf_h(uint16x16_t vecj, uint16x16_t veck, uint16x16_t idx)
+        ///   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorShuffleEach128(Vector256<ushort> vector0, Vector256<ushort> vector1, Vector256<ushort> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvpermi_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvpermi_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvshuf_w(int32x8_t vec0, int32x8_t vec1, int32x8_t idx)
+        ///   LASX: XVSHUF.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector0, Vector256<int> vector1, Vector256<int> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvshuf_w(uint32x8_t vecj, uint32x8_t veck, uint32x8_t idx)
+        ///   LASX: XVSHUF.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector0, Vector256<uint> vector1, Vector256<uint> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvshuf_d(int64x4_t vec0, int64x4_t vec1, int64x4_t idx)
+        ///   LASX: XVSHUF.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorShuffleEach128(Vector256<long> vector0, Vector256<long> vector1, Vector256<long> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvshuf_d(uint64x4_t vecj, uint64x4_t veck, uint64x4_t idx)
+        ///   LASX: XVSHUF.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorShuffleEach128(Vector256<ulong> vector0, Vector256<ulong> vector1, Vector256<ulong> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvshuf4i_b(int8x32_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector256<sbyte> VectorShuffleBy4Elements(Vector256<sbyte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvshuf4i_b(uint8x32_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector256<byte> VectorShuffleBy4Elements(Vector256<byte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvshuf4i_h(int16x16_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector256<short> VectorShuffleBy4Elements(Vector256<short> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvshuf4i_h(uint16x16_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector256<ushort> VectorShuffleBy4Elements(Vector256<ushort> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvshuf4i_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<int> VectorShuffleBy4Elements(Vector256<int> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvshuf4i_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<uint> VectorShuffleBy4Elements(Vector256<uint> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvshuf4i_d(int64x4_t vec0, uint64x4_t vec1, uint8_t idx)
+        ///   LASX: XVSHUF4I.D Xd.4D, Xj.4D, ui4
+        /// </summary>
+        public static Vector256<long> VectorShuffleBy4Elements(Vector256<long> vector0, Vector256<long> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvshuf4i_d(uint64x4_t vec0, uint64x4_t vec1, uint8_t idx)
+        ///   LASX: XVSHUF4I.D Xd.4D, Xj.4D, ui4
+        /// </summary>
+        public static Vector256<ulong> VectorShuffleBy4Elements(Vector256<ulong> vector0, Vector256<ulong> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvilvl_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVILVL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionLowerEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvilvl_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVILVL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionLowerEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvilvl_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVILVL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionLowerEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvilvl_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVILVL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionLowerEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvilvl_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVILVL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionLowerEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvilvl_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVILVL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionLowerEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvilvl_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVILVL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionLowerEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvilvl_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVILVL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionLowerEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvilvh_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVILVH.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionHightEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvilvh_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVILVH.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionHightEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvilvh_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVILVH.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionHightEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvilvh_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVILVH.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionHightEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvilvh_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVILVH.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionHightEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvilvh_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVILVH.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionHightEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvilvh_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVILVH.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionHightEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvilvh_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVILVH.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionHightEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvpackev_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPACKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionEven(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvpackev_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPACKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionEven(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvpackev_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPACKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionEven(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvpackev_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPACKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionEven(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvpackev_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPACKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionEven(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvpackev_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPACKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionEven(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvpackev_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPACKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionEven(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvpackev_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPACKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionEven(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvpackod_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPACKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionOdd(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvpackod_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPACKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionOdd(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvpackod_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPACKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionOdd(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvpackod_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPACKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionOdd(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvpackod_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPACKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionOdd(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvpackod_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPACKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionOdd(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvpackod_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPACKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionOdd(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvpackod_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPACKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionOdd(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvpickev_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPICKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorEvenElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvpickev_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPICKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorEvenElementsJoinEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvpickev_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPICKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorEvenElementsJoinEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvpickev_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPICKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorEvenElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvpickev_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPICKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorEvenElementsJoinEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvpickev_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPICKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorEvenElementsJoinEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvpickev_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPICKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorEvenElementsJoinEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvpickev_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPICKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorEvenElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvpickod_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPICKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorOddElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvpickod_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPICKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorOddElementsJoinEach128(Vector256<byte> left, Vector256<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvpickod_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPICKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorOddElementsJoinEach128(Vector256<short> left, Vector256<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvpickod_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPICKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorOddElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvpickod_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPICKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorOddElementsJoinEach128(Vector256<int> left, Vector256<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvpickod_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPICKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorOddElementsJoinEach128(Vector256<uint> left, Vector256<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvpickod_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPICKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorOddElementsJoinEach128(Vector256<long> left, Vector256<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvpickod_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPICKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorOddElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvrepl128vei(uint8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> VectorElementReplicateEach128(Vector256<byte> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvrepl128vei(int8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> VectorElementReplicateEach128(Vector256<sbyte> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvrepl128vei(int16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<short> VectorElementReplicateEach128(Vector256<short> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvrepl128vei(uint16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<ushort> VectorElementReplicateEach128(Vector256<ushort> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvrepl128vei(int32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
+        /// </summary>
+        public static Vector256<int> VectorElementReplicateEach128(Vector256<int> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvrepl128vei(uint32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
+        /// </summary>
+        public static Vector256<uint> VectorElementReplicateEach128(Vector256<uint> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvrepl128vei(int64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
+        /// </summary>
+        public static Vector256<long> VectorElementReplicateEach128(Vector256<long> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvrepl128vei(uint64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
+        /// </summary>
+        public static Vector256<ulong> VectorElementReplicateEach128(Vector256<ulong> vector, const byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvextrins_b(int8x32_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector258<sbyte> UpdateOneVectorElementEach128(Vector258<sbyte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x32_t xvextrins_b(uint8x32_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector258<byte> UpdateOneVectorElementEach128(Vector258<byte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvextrins_h(int16x16_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector258<short> UpdateOneVectorElementEach128(Vector258<short> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x16_t xvextrins_h(uint16x16_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector258<ushort> UpdateOneVectorElementEach128(Vector258<ushort> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvextrins_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector258<int> UpdateOneVectorElementEach128(Vector258<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x8_t xvextrins_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector258<uint> UpdateOneVectorElementEach128(Vector258<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvextrins_d(int64x4_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector258<long> UpdateOneVectorElementEach128(Vector258<long> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x4_t xvextrins_d(uint64x4_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector258<ulong> UpdateOneVectorElementEach128(Vector258<ulong> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x32_t xvsigncov_b(int8x32_t sign, int8x32_t data)
+        ///   LASX: XVSIGNCOV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector258<sbyte> VectorElementNegatedBySign(Vector258<sbyte> sign, Vector258<sbyte> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x16_t xvsigncov_h(int16x16_t sign, int16x16_t data)
+        ///   LASX: XVSIGNCOV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector258<short> VectorElementNegatedBySign(Vector258<short> sign, Vector258<short> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x8_t xvsigncov_w(int32x8_t sign, int32x8_t data)
+        ///   LASX: XVSIGNCOV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector258<int> VectorElementNegatedBySign(Vector258<int> sign, Vector258<int> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x4_t xvsigncov_d(int64x4_t sign, int64x4_t data)
+        ///   LASX: XVSIGNCOV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector258<long> VectorElementNegatedBySign(Vector258<long> sign, Vector258<long> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitclri_b(int8x32_t a, const int n)
+        ///   LASX: XVBITCLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitclri_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITCLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitclri_h(int16x16_t a, const int n)
+        ///   LASX: XVBITCLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorElementBitClear(Vector256<short> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitclri_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITCLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<int> VectorElementBitClear(Vector256<int> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitclri_d(int64x4_t a, const int n)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorElementBitClear(Vector256<long> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitclri_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitclr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITCLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, Vector256<sbyte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitclr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITCLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, Vector256<byte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitclr_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITCLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementBitClear(Vector256<short> value, Vector256<short> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitclr_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITCLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, Vector256<ushort> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvbitclr_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITCLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementBitClear(Vector256<int> value, Vector256<int> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitclr_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITCLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, Vector256<uint> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitclr_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITCLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementBitClear(Vector256<long> value, Vector256<long> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitclr_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITCLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, Vector256<ulong> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitseti_b(int8x32_t a, const int n)
+        ///   LASX: XVBITSETI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitseti_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITSETI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitseti_h(int16x16_t a, const int n)
+        ///   LASX: XVBITSETI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorElementBitSet(Vector256<short> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitseti_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITSETI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<int> VectorElementBitSet(Vector256<int> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitseti_d(int64x4_t a, const int n)
+        ///   LASX: XVBITSETI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorElementBitSet(Vector256<long> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitseti_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITSETI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitset_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITSET.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, Vector256<sbyte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitset_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITSET.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, Vector256<byte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitset_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITSET.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementBitSet(Vector256<short> value, Vector256<short> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitset_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITSET.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, Vector256<ushort> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvbitset_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITSET.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementBitSet(Vector256<int> value, Vector256<int> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitset_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITSET.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, Vector256<uint> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitset_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITSET.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementBitSet(Vector256<long> value, Vector256<long> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitset_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITSET.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, Vector256<ulong> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitrevi_b(int8x32_t a, const int n)
+        ///   LASX: XVBITREVI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitrevi_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITREVI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitrevi_h(int16x16_t a, const int n)
+        ///   LASX: XVBITREVI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitrevi_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITREVI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitrevi_d(int64x4_t a, const int n)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitrevi_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvbitrev_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITREV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, Vector256<sbyte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvbitrev_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITREV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, Vector256<byte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvbitrev_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITREV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, Vector256<short> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvbitrev_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITREV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, Vector256<ushort> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvbitrev_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITREV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, Vector256<int> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvbitrev_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITREV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, Vector256<uint> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvbitrev_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITREV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, Vector256<long> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvbitrev_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITREV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, Vector256<ulong> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvfrstp_b(int8x32_t value, int8x32_t save)
+        ///   LASX: XVFRSTP.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, Vector256<sbyte> save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvfrstp_h(int16x16_t value, int16x16_t save)
+        ///   LASX: XVFRSTP.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, Vector256<short> save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvfrstpi_b(int8x32_t value, uint8_t save)
+        ///   LASX: XVFRSTPI.B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, const byte save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvfrstpi_h(int16x16_t value, uint8_t save)
+        ///   LASX: XVFRSTPI.H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, const byte save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x32_t xvsat_b(int8x32_t value, uint8_t ui3)
+        ///   LASX: XVSAT.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorSaturate(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x16_t xvsat_h(int16x16_t value, uint8_t ui4)
+        ///   LASX: XVSAT.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorSaturate(Vector256<short> value, [ConstantExpected(Max = (byte)(15))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t xvsat_w(int32x8_t value, uint8_t ui5)
+        ///   LASX: XVSAT.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> VectorSaturate(Vector256<int> value, [ConstantExpected(Max = (byte)(31))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t xvsat_d(int64x4_t value, uint8_t ui6)
+        ///   LASX: XVSAT.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorSaturate(Vector256<long> value, [ConstantExpected(Max = (byte)(63))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x32_t xvsat_bu(uint8x32_t value, uint8_t ui3)
+        ///   LASX: XVSAT.BU Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorSaturateUnsigned(Vector256<byte> value, [ConstantExpected(Max = (byte)(7))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x16_t xvsat_hu(uint16x16_t value, uint8_t ui4)
+        ///   LASX: XVSAT.HU Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorSaturateUnsigned(Vector256<ushort> value, [ConstantExpected(Max = (byte)(15))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x8_t xvsat_wu(uint32x8_t value, uint8_t ui5)
+        ///   LASX: XVSAT.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorSaturateUnsigned(Vector256<uint> value, [ConstantExpected(Max = (byte)(31))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x4_t xvsat_du(uint64x4_t value, uint8_t ui6)
+        ///   LASX: XVSAT.DU Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorSaturateUnsigned(Vector256<ulong> value, [ConstantExpected(Max = (byte)(63))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x8_t vfclass_s(float32x8_t a)
+        ///   LASX: XVFCLASS.S Vd.8S, Vj.8S
+        /// </summary>
+        public static Vector256<int> FloatClass(Vector256<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x4_t vfclass_d(float64x4_t a)
+        ///   LASX: XVFCLASS.D Vd.4D, Vj.4D
+        /// </summary>
+        public static Vector256<long> FloatClass(Vector256<double> value) { throw new PlatformNotSupportedException(); }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.cs
new file mode 100644
index 00000000000000..1fa8728238d49a
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lasx.cs
@@ -0,0 +1,5751 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    /// <summary>
+    /// This class provides access to the LASX-256bits hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class Lasx : Lsx
+    {
+        internal Lasx() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// int8x32_t xvadd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right) => Add(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvadd_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right) => Add(left, right);
+
+        /// <summary>
+        /// int16x16_t xvadd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Add(Vector256<short> left, Vector256<short> right) => Add(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvadd_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right) => Add(left, right);
+
+        /// <summary>
+        /// int32x8_t xvadd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Add(Vector256<int> left, Vector256<int> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvadd_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// int64x4_t xvadd_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Add(Vector256<long> left, Vector256<long> right) => Add(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvadd_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right) => Add(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfadd_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFADD.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Add(Vector256<float> left, Vector256<float> right) => Add(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfadd_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Add(Vector256<double> left, Vector256<double> right) => Add(left, right);
+
+        /// <summary>
+        /// int8x32_t xvsadd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x16_t xvsadd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int32x8_t xvsadd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> AddSaturate(Vector256<int> left, Vector256<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x4_t xvsadd_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddSaturate(Vector256<long> left, Vector256<long> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvsadd_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSADD.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvsadd_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSADD.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsadd_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSADD.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AddSaturate(Vector256<uint> left, Vector256<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsadd_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSADD.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddSaturate(Vector256<ulong> left, Vector256<ulong> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x16_t xvhaddw_h_b(int3x32_t a, int3x32_t b)
+        ///   LASX: XVHADDW.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AddOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvhaddw_hu_bu(uint3x32_t a, uint3x32_t b)
+        ///   LASX: XVHADDW.HU.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AddOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x8_t xvhaddw_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVHADDW.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> AddOddEvenElementsWidening(Vector256<short> left, Vector256<short> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvhaddw_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVHADDW.WU.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AddOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x4_t xvhaddw_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVHADDW.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> AddOddEvenElementsWidening(Vector256<int> left, Vector256<int> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvhaddw_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVHADDW.DU.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AddOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x2_t xvhaddw_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVHADDW.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddOddEvenElementsWidening(Vector256<long> left, Vector256<long> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x2_t xvhaddw_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVHADDW.QU.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x16_t xvaddwev_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWEV.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvaddwev_h_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVADDWEV.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> AddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x8_t xvaddwev_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWEV.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddEvenElementsWidening(Vector256<short> left, Vector256<short> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvaddwev_w_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVADDWEV.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> AddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x4_t xvaddwev_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWEV.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<int> left, Vector256<int> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvaddwev_d_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVADDWEV.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> AddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x2_t xvaddwev_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWEV.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<long> left, Vector256<long> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x2_t xvaddwev_q_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVADDWEV.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x16_t xvaddwod_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddOddElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvaddwod_h_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVADDWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> AddOddElementsWidening(Vector256<byte> left, Vector256<byte> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x8_t xvaddwod_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWOD.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddOddElementsWidening(Vector256<short> left, Vector256<short> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvaddwod_w_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVADDWOD.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> AddOddElementsWidening(Vector256<ushort> left, Vector256<ushort> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x4_t xvaddwod_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWOD.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<int> left, Vector256<int> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvaddwod_d_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVADDWOD.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> AddOddElementsWidening(Vector256<uint> left, Vector256<uint> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x2_t xvaddwod_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWOD.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<long> left, Vector256<long> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x2_t xvaddwod_q_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVADDWOD.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AddOddElementsWidening(Vector256<ulong> left, Vector256<ulong> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x16_t xvaddwev_h_bu_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWEV.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddEvenElementsWidening(Vector256<byte> left, Vector256<sbyte> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x8_t xvaddwev_w_hu_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWEV.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddEvenElementsWidening(Vector256<ushort> left, Vector256<short> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x4_t xvaddwev_d_wu_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWEV.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<uint> left, Vector256<int> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x2_t xvaddwev_q_du_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWEV.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddEvenElementsWidening(Vector256<ulong> left, Vector256<long> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x16_t xvaddwod_h_bu_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVADDWOD.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AddOddElementsWidening(Vector256<byte> left, Vector256<sbyte> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x8_t xvaddwod_w_hu_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVADDWOD.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> AddOddElementsWidening(Vector256<ushort> left, Vector256<short> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x4_t xvaddwod_d_wu_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVADDWOD.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<uint> left, Vector256<int> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x2_t xvaddwod_q_du_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVADDWOD.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AddOddElementsWidening(Vector256<ulong> left, Vector256<long> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<sbyte> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.HU.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector256<byte> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<short> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.WU.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector256<ushort> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<int> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.DU.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<uint> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector256<long> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: XVHADDW.QU.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector256<ulong> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: sum_all_float_elements witin vector.
+        /// </summary>
+        public static Vector64<float> AddHorizontalElements(Vector256<float> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LASX: sum_all_double_elements witin vector.
+        /// </summary>
+        public static Vector64<double> AddHorizontalElements(Vector256<double> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        /// int8x32_t xvsub_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvsub_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int16x16_t xvsub_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvsub_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int32x8_t xvsub_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsub_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int64x4_t xvsub_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsub_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right) => Subtract(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfsub_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFSUB.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right) => Subtract(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfsub_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int16x16_t xvhsubw_h_b(int3x32_t a, int3x32_t b)
+        ///   LASX: XVHSUBW.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> SubtractOddEvenElementsWidening(Vector256<sbyte> left, Vector256<sbyte> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvhsubw_hu_bu(uint3x32_t a, uint3x32_t b)
+        ///   LASX: XVHSUBW.HU.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> SubtractOddEvenElementsWidening(Vector256<byte> left, Vector256<byte> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x8_t xvhsubw_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVHSUBW.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> SubtractOddEvenElementsWidening(Vector256<short> left, Vector256<short> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvhsubw_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVHSUBW.WU.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> SubtractOddEvenElementsWidening(Vector256<ushort> left, Vector256<ushort> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x4_t xvhsubw_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVHSUBW.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> SubtractOddEvenElementsWidening(Vector256<int> left, Vector256<int> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvhsubw_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVHSUBW.DU.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> SubtractOddEvenElementsWidening(Vector256<uint> left, Vector256<uint> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x2_t xvhsubw_q_d(int64x4_t a, int64x4_t b)  TODO: long --> longlong 128bits.
+        ///   LASX: XVHSUBW.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> SubtractOddEvenElementsWidening(Vector256<long> left, Vector256<long> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x2_t xvhsubw_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVHSUBW.QU.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> SubtractOddEvenElementsWidening(Vector256<ulong> left, Vector256<ulong> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int8x32_t xvssub_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvssub_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSSUB.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int16x16_t xvssub_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvssub_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSSUB.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int32x8_t xvssub_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> SubtractSaturate(Vector256<int> left, Vector256<int> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvssub_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSSUB.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> SubtractSaturate(Vector256<uint> left, Vector256<uint> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int64x4_t xvssub_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> SubtractSaturate(Vector256<long> left, Vector256<long> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvssub_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSSUB.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> SubtractSaturate(Vector256<ulong> left, Vector256<ulong> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int8x32_t xvmul_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Multiply(Vector256<sbyte> left, Vector256<sbyte> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmul_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMUL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Multiply(Vector256<byte> left, Vector256<byte> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmul_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Multiply(Vector256<short> left, Vector256<short> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmul_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMUL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Multiply(Vector256<ushort> left, Vector256<ushort> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmul_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULW Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Multiply(Vector256<int> left, Vector256<int> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmul_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMUL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Multiply(Vector256<uint> left, Vector256<uint> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmul_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Multiply(Vector256<long> left, Vector256<long> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmul_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Multiply(Vector256<ulong> left, Vector256<ulong> right) => Multiply(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmul_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMUL.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right) => Multiply(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmul_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMUL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int8x32_t xvmuh_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMUH.B Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<sbyte> MultiplyHight(Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmuh_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMUH.BU Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<byte> MultiplyHight(Vector256<byte> left, Vector256<byte> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmuh_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMUH.H Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<short> MultiplyHight(Vector256<short> left, Vector256<short> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmuh_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMUH.HU Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<ushort> MultiplyHight(Vector256<ushort> left, Vector256<ushort> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmuh_w(int32x8_t a, int32x8_t b)
+        ///   LASX: VMUL.W Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<int> MultiplyHight(Vector256<int> left, Vector256<int> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmuh_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMUH.WU Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<uint> MultiplyHight(Vector256<uint> left, Vector256<uint> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmuh_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMUH.D Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyHight(Vector256<long> left, Vector256<long> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmuh_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMUH.DU Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyHight(Vector256<ulong> left, Vector256<ulong> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int8x32_t xvdiv_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVDIV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Divide(Vector256<sbyte> left, Vector256<sbyte> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvdiv_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVDIV.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Divide(Vector256<byte> left, Vector256<byte> right) => Divide(left, right);
+
+        /// <summary>
+        /// int16x16_t xvdiv_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVDIV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Divide(Vector256<short> left, Vector256<short> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvdiv_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVDIV.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Divide(Vector256<ushort> left, Vector256<ushort> right) => Divide(left, right);
+
+        /// <summary>
+        /// int32x8_t xvdiv_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVDIV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Divide(Vector256<int> left, Vector256<int> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvdiv_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVDIV.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Divide(Vector256<uint> left, Vector256<uint> right) => Divide(left, right);
+
+        /// <summary>
+        /// int64x4_t xvdiv_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVDIV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Divide(Vector256<long> left, Vector256<long> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvdiv_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVDIV.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Divide(Vector256<ulong> left, Vector256<ulong> right) => Divide(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfdiv_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFDIV.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right) => Divide(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfdiv_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFDIV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right) => Divide(left, right);
+
+        /// <summary>
+        /// int8x32_t xvmod_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Modulo(Vector256<sbyte> left, Vector256<sbyte> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmod_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMOD.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Modulo(Vector256<byte> left, Vector256<byte> right) => Modulo(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmod_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Modulo(Vector256<short> left, Vector256<short> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmod_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMOD.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Modulo(Vector256<ushort> left, Vector256<ushort> right) => Modulo(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmod_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Modulo(Vector256<int> left, Vector256<int> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmod_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMOD.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Modulo(Vector256<uint> left, Vector256<uint> right) => Modulo(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmod_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Modulo(Vector256<long> left, Vector256<long> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmod_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMOD.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Modulo(Vector256<ulong> left, Vector256<ulong> right) => Modulo(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmadd_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMADD.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplyAdd(Vector256<float> left, Vector256<float> right, Vector256<float> addend) => FusedMultiplyAdd(left, right, addend);
+
+        /// <summary>
+        /// float64x4_t xvfmadd_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMADD.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplyAdd(Vector256<double> left, Vector256<double> right, Vector256<double> addend) => FusedMultiplyAdd(left, right, addend);
+
+        /// <summary>
+        /// float32x8_t xvfnmadd_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFNMADD.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplyAddNegated(Vector256<float> left, Vector256<float> right, Vector256<float> addend) => FusedMultiplyAddNegated(left, right, addend);
+
+        /// <summary>
+        /// float64x4_t xvfnmadd_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFNMADD.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplyAddNegated(Vector256<double> left, Vector256<double> right, Vector256<double> addend) => FusedMultiplyAddNegated(left, right, addend);
+
+        /// <summary>
+        /// int8x32_t xvmadd_b(int8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B               //NOTE: The Vd is both input and output while input as addend.
+        /// </summary>
+        public static Vector256<sbyte> MultiplyAdd(Vector256<sbyte> addend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmadd_b(uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVMADD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> MultiplyAdd(Vector256<byte> addend, Vector256<byte> left, Vector256<byte> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int16x16_t xvmadd_h(int16x16_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> MultiplyAdd(Vector256<short> addend, Vector256<short> left, Vector256<short> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmadd_h(uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMADD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> MultiplyAdd(Vector256<ushort> addend, Vector256<ushort> left, Vector256<ushort> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int32x8_t xvmadd_w(int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> MultiplyAdd(Vector256<int> addend, Vector256<int> left, Vector256<int> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmadd_w(uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMADD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> MultiplyAdd(Vector256<uint> addend, Vector256<uint> left, Vector256<uint> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int64x4_t xvmadd_d(int64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyAdd(Vector256<long> addend, Vector256<long> left, Vector256<long> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmadd_d(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVMADD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyAdd(Vector256<ulong> addend, Vector256<ulong> left, Vector256<ulong> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmsub_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFMSUB.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplySubtract(Vector256<float> left, Vector256<float> right, Vector256<float> minuend) => FusedMultiplySubtract(left, right, minuend);
+
+        /// <summary>
+        /// float64x4_t xvfmsub_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFMSUB.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplySubtract(Vector256<double> left, Vector256<double> right, Vector256<double> minuend) => FusedMultiplySubtract(left, right, minuend);
+
+        /// <summary>
+        /// float32x8_t xvfnmsub_s(float32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVFNMSUB.S Xd.8S, Xj.8S, Xk.8S, Xa.8S
+        /// </summary>
+        public static Vector256<float> FusedMultiplySubtractNegated(Vector256<float> left, Vector256<float> right, Vector256<float> minuend) => FusedMultiplySubtractNegated(left, right, minuend);
+
+        /// <summary>
+        /// float64x4_t xvfnmsub_d(float64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVFNMSUB.D Xd.4D, Xj.4D, Xk.4D, Xa.4D
+        /// </summary>
+        public static Vector256<double> FusedMultiplySubtractNegated(Vector256<double> left, Vector256<double> right, Vector256<double> minuend) => FusedMultiplySubtractNegated(left, right, minuend);
+
+        /// <summary>
+        /// int8x32_t xvmsub_b(int8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> MultiplySubtract(Vector256<sbyte> minuend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmsub_b(uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVMSUB.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> MultiplySubtract(Vector256<byte> minuend, Vector256<byte> left, Vector256<byte> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x16_t xvmsub_h(int16x16_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> MultiplySubtract(Vector256<short> minuend, Vector256<short> left, Vector256<short> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmsub_h(uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMSUB.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> MultiplySubtract(Vector256<ushort> minuend, Vector256<ushort> left, Vector256<ushort> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int32x8_t xvmsub_w(int32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> MultiplySubtract(Vector256<int> minuend, Vector256<int> left, Vector256<int> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmsub_w(uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMSUB.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> MultiplySubtract(Vector256<uint> minuend, Vector256<uint> left, Vector256<uint> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int64x4_t xvmsub_d(int64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplySubtract(Vector256<long> addend, Vector256<long> left, Vector256<long> right) => MultiplySubtract(addend, left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmsub_d(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVMSUB.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplySubtract(Vector256<ulong> addend, Vector256<ulong> left, Vector256<ulong> right) => MultiplySubtract(addend, left, right);
+
+        /// <summary>
+        /// int16x16_t xvmaddwev_h_b(int16x16_t a, int8x8_t b, int8x8_t c)
+        ///   LASX: XVMADDWEV.H.B Xd.16H, Xj.8B, Xk.8B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningLowerAndAdd(Vector256<short> addend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmaddwev_h_bu(uint16x16_t a, uint8x8_t b, uint8x8_t c)
+        ///   LASX: XVMADDWEV.H.BU Xd.16H, Xj.8B, Xk.8B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningLowerAndAdd(Vector256<ushort> addend, Vector128<byte> left, Vector128<byte> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int32x8_t xvmaddwev_w_h(int32x8_t a, int16x4_t b, int16x4_t c)
+        ///   LASX: XVMADDWEV.W.H Xd.8W, Xj.4H, Xk.4H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningLowerAndAdd(Vector256<int> addend, Vector128<short> left, Vector128<short> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmaddwev_w_hu(uint32x8_t a, uint16x4_t b, uint16x4_t c)
+        ///   LASX: XVMADDWEV.W.HU Xd.8W, Xj.4H, Xk.4H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningLowerAndAdd(Vector256<uint> addend, Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int64x4_t xvmaddwev_d_w(int64x4_t a, int32x2_t b, int32x2_t c)
+        ///   LASX: XVMADDWEV.D.W Xd.4D, Xj.2S, Xk.2S
+        /// </summary>
+        public static Vector256<long> MultiplyWideningLowerAndAdd(Vector256<long> addend, Vector128<int> left, Vector128<int> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmaddwev_d_wu(uint64x4_t a, uint32x2_t b, uint32x2_t c)
+        ///   LASX: XVMADDWEV.D.WU Xd.4D, Xj.2S, Xk.2S
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningLowerAndAdd(Vector256<ulong> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int16x16_t xvmaddwod_h_b(int16x16_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVMADDWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningUpperAndAdd(Vector256<short> addend, Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmaddwod_h_bu(uint16x16_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVMADDWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningUpperAndAdd(Vector256<ushort> addend, Vector256<byte> left, Vector256<byte> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int32x8_t xvmaddwod_w_h(int32x8_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVMADDWOD.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningUpperAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmaddwod_w_hu(uint32x8_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVMADDWOD.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningUpperAndAdd(Vector256<uint> addend, Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int64x4_t xvmaddwod_d_w(int64x4_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVMADDWOD.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> MultiplyWideningUpperAndAdd(Vector256<long> addend, Vector256<int> left, Vector256<int> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmaddwod_d_wu(uint64x4_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVMADDWOD.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningUpperAndAdd(Vector256<ulong> addend, Vector256<uint> left, Vector256<uint> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        ///  int8x32_t xvmsknz_b(int8x32_t value)
+        ///   LASX: XVMSKNZ.B Vd.32B, Vj.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareNotEqualZeroEach128(Vector256<sbyte> value) => CompareNotEqualZeroEach128(value);
+
+        /// <summary>
+        ///  uint8x32_t xvmsknz_b(uint8x32_t value)
+        ///   LASX: XVMSKNZ.B Vd.32B, Vj.32B
+        /// </summary>
+        public static Vector256<byte> CompareNotEqualZeroEach128(Vector256<byte> value) => CompareNotEqualZeroEach128(value);
+
+        /// <summary>
+        /// int8x32_t xvseqi_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVSEQI.B Xd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int16x16_t xvseqi_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSEQI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> CompareEqual(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int32x8_t xvseqi_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSEQI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> CompareEqual(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int64x4_t xvseqi_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSEQI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> CompareEqual(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int8x32_t xvseq_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSEQ.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvseq_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSEQ.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int16x16_t xvseq_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSEQ.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvseq_h(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSEQ.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int32x8_t xvseq_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvseq_w(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSEQ.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int64x4_t xvseq_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvseq_d(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_ceq_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CEQ.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_ceq_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CEQ.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right) => CompareEqual(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvmskltz_b(int8x32_t value)
+        ///   LASX: XVMSKLTZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThanZeroEach128(Vector256<sbyte> value) => CompareLessThanZeroEach128(value);
+
+        /// <summary>
+        ///  int16x16_t xvmskltz_h(int16x16_t value)
+        ///   LASX: XVMSKLTZ.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> CompareLessThanZeroEach128(Vector256<short> value) => CompareLessThanZeroEach128(value);
+
+        /// <summary>
+        ///  int32x8_t xvmskltz_w(int32x8_t value)
+        ///   LASX: XVMSKLTZ.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> CompareLessThanZeroEach128(Vector256<int> value) => CompareLessThanZeroEach128(value);
+
+        /// <summary>
+        ///  int64x4_t xvmskltz_d(int64x4_t value)
+        ///   LASX: XVMSKLTZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThanZeroEach128(Vector256<long> value) => CompareLessThanZeroEach128(value);
+
+        /// <summary>
+        /// int8x32_t xvslti_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVSLTI.Bd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// int16x16_t xvslti_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSLTI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> CompareLessThan(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// int32x8_t xvslti_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSLTI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> CompareLessThan(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// int64x4_t xvslti_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSLTI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> CompareLessThan(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// uint8x32_t xvslt_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLT.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvslt_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLT.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvslt_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLT.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvslt_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLT.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvslt_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareLessThan(Vector256<int> left, Vector256<int> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareLessThan(Vector256<uint> left, Vector256<uint> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvslt_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThan(Vector256<long> left, Vector256<long> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvslt_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLT.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareLessThan(Vector256<ulong> left, Vector256<ulong> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_clt_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLT.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_clt_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// int8x32_t xvslei_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVSLEI.Bd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// int16x16_t xvslei_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVSLEI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// int32x8_t xvslei_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVSLEI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// int64x4_t xvslei_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVSLEI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// uint8x32_t xvsle_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvsle_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsle_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsle_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<long> left, Vector256<long> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvslei_bu(uint8x32_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.BU Xd.32B, Xj.32B, ui5
+        /// </summary>
+        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint16x16_t xvslei_hu(uint16x16_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.HU Xd.16H, Xj.16H, ui5
+        /// </summary>
+        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint32x8_t xvslei_wu(uint32x8_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint64x4_t xvslei_du(uint64x4_t a, uint8_t ui5)
+        ///   LASX: XVSLEI.DU Xd.4D, Xj.4D, ui5
+        /// </summary>
+        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint8x32_t xvsle_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvsle_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareLessThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsle_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLE.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareLessThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_cle_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<int> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_cle_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvsle_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLE.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvsle_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLE.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvsle_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLE.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvsle_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLE.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsle_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLE.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvsle_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLE.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThan(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsle_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvsle_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLE.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareGreaterThan(Vector256<ulong> left, Vector256<ulong> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_cle_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLE.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_cle_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLE.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvmskgez_b(int8x32_t value)
+        ///   LASX: XVMSKGEZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareGreaterThanOrEqualZeroEach128(Vector256<sbyte> value) => CompareGreaterThanOrEqualZeroEach128(value);
+
+        /// <summary>
+        /// uint8x32_t xvslt_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLT.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvslt_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLT.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvslt_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVSLT.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvslt_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVSLT.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvslt_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVSLT.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> CompareGreaterThanOrEqual(Vector256<int> left, Vector256<int> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvslt_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVSLT.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> CompareGreaterThanOrEqual(Vector256<uint> left, Vector256<uint> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvslt_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVSLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> CompareGreaterThanOrEqual(Vector256<long> left, Vector256<long> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvslt_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVSLT.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> CompareGreaterThanOrEqual(Vector256<ulong> left, Vector256<ulong> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvfcmp_clt_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFCMP.CLT.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvfcmp_clt_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFCMP.CLT.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// int8x32_t xvmaxi_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVMAXI.B Xd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> Max(Vector256<sbyte> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint8x32_t xvmaxi_bu(uint8x32_t a, int8_t si5)
+        ///   LASX: XVMAXI.BU Xd.32B, Xj.32B, ui5
+        /// </summary>
+        public static Vector256<byte> Max(Vector256<byte> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int16x16_t xvmaxi_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVMAXI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> Max(Vector256<short> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint16x16_t xvmaxi_hu(uint16x16_t a, int8_t si5)
+        ///   LASX: XVMAXI.HU Xd.16H, Xj.16H, ui5
+        /// </summary>
+        public static Vector256<ushort> Max(Vector256<ushort> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int32x8_t xvmaxi_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVMAXI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> Max(Vector256<int> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint32x8_t xvmaxi_wu(uint32x8_t a, int8_t si5)
+        ///   LASX: XVMAXI.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> Max(Vector256<uint> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int64x4_t xvmaxi_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVMAXI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> Max(Vector256<long> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint64x4_t xvmaxi_du(uint64x4_t a, int8_t si5)
+        ///   LASX: XVMAXI.DU Xd.4D, Xj.4D, ui5
+        /// </summary>
+        public static Vector256<ulong> Max(Vector256<ulong> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int8x32_t xvmax_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMAX.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right) => Max(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmax_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMAX.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right) => Max(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmax_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMAX.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Max(Vector256<short> left, Vector256<short> right) => Max(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmax_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMAX.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right) => Max(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmax_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMAX.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Max(Vector256<int> left, Vector256<int> right) => Max(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmax_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMAX.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right) => Max(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmax_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMAX.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Max(Vector256<long> left, Vector256<long> right) => Max(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmax_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMAX.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Max(Vector256<ulong> left, Vector256<ulong> right) => Max(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmax_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMAX.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Max(Vector256<float> left, Vector256<float> right) => Max(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmax_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMAX.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Max(Vector256<double> left, Vector256<double> right) => Max(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmaxa_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMAXA.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> MaxFloatAbsolute(Vector256<float> left, Vector256<float> right) => MaxFloatAbsolute(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmaxa_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMAXA.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> MaxFloatAbsolute(Vector256<double> left, Vector256<double> right) => MaxFloatAbsolute(left, right);
+
+        /// <summary>
+        /// int8x32_t xvmini_b(int8x32_t a, int8_t si5)
+        ///   LASX: XVMINI.B Xd.32B, Xj.32B, si5
+        /// </summary>
+        public static Vector256<sbyte> Min(Vector256<sbyte> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint8x32_t xvmini_bu(uint8x32_t a, int8_t si5)
+        ///   LASX: XVMINI.BU Xd.32B, Xj.32B, ui5
+        /// </summary>
+        public static Vector256<byte> Min(Vector256<byte> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int16x16_t xvmini_h(int16x16_t a, int8_t si5)
+        ///   LASX: XVMINI.H Xd.16H, Xj.16H, si5
+        /// </summary>
+        public static Vector256<short> Min(Vector256<short> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint16x16_t xvmini_hu(uint16x16_t a, int8_t si5)
+        ///   LASX: XVMINI.HU Xd.16H, Xj.16H, ui5
+        /// </summary>
+        public static Vector256<ushort> Min(Vector256<ushort> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int32x8_t xvmini_w(int32x8_t a, int8_t si5)
+        ///   LASX: XVMINI.W Xd.8W, Xj.8W, si5
+        /// </summary>
+        public static Vector256<int> Min(Vector256<int> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint32x8_t xvmini_wu(uint32x8_t a, int8_t si5)
+        ///   LASX: XVMINI.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> Min(Vector256<uint> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int64x4_t xvmini_d(int64x4_t a, int8_t si5)
+        ///   LASX: XVMINI.D Xd.4D, Xj.4D, si5
+        /// </summary>
+        public static Vector256<long> Min(Vector256<long> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint64x4_t xvmini_du(uint64x4_t a, int8_t si5)
+        ///   LASX: XVMINI.DU Xd.4D, Xj.4D, ui5
+        /// </summary>
+        public static Vector256<ulong> Min(Vector256<ulong> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int8x32_t xvmin_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMIN.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right) => Min(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvmin_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMIN.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right) => Min(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmin_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMIN.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Min(Vector256<short> left, Vector256<short> right) => Min(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmin_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMIN.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right) => Min(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmin_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMIN.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Min(Vector256<int> left, Vector256<int> right) => Min(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmin_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMIN.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right) => Min(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmin_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMIN.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Min(Vector256<long> left, Vector256<long> right) => Min(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmin_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMIN.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Min(Vector256<ulong> left, Vector256<ulong> right) => Min(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmin_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMIN.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> Min(Vector256<float> left, Vector256<float> right) => Min(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmin_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMIN.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> Min(Vector256<double> left, Vector256<double> right) => Min(left, right);
+
+        /// <summary>
+        /// float32x8_t xvfmina_s(float32x8_t a, float32x8_t b)
+        ///   LASX: XVFMINA.S Xd.8S, Xj.8S, Xk.8S
+        /// </summary>
+        public static Vector256<float> MinFloatAbsolute(Vector256<float> left, Vector256<float> right) => MinFloatAbsolute(left, right);
+
+        /// <summary>
+        /// float64x4_t xvfmina_d(float64x4_t a, float64x4_t b)
+        ///   LASX: XVFMINA.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<double> MinFloatAbsolute(Vector256<double> left, Vector256<double> right) => MinFloatAbsolute(left, right);
+
+        /// <summary>
+        /// int8x32_t xvbitsel_v(uint8x32_t a, int8x32_t b, int8x32_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> BitwiseSelect(Vector256<sbyte> select, Vector256<sbyte> left, Vector256<sbyte> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint8x32_t xvbitsel_v(uint8x32_t a, uint8x32_t b, uint8x32_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> BitwiseSelect(Vector256<byte> select, Vector256<byte> left, Vector256<byte> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int16x16_t xvbitsel_v(uint16x16_t a, int16x16_t b, int16x16_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> BitwiseSelect(Vector256<short> select, Vector256<short> left, Vector256<short> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint16x16_t xvbitsel_v(uint16x16_t a, uint16x16_t b, uint16x16_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> BitwiseSelect(Vector256<ushort> select, Vector256<ushort> left, Vector256<ushort> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int32x8_t xvbitsel_v(uint32x8_t a, int32x8_t b, int32x8_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> BitwiseSelect(Vector256<int> select, Vector256<int> left, Vector256<int> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint32x8_t xvbitsel_v(uint32x8_t a, uint32x8_t b, uint32x8_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> BitwiseSelect(Vector256<uint> select, Vector256<uint> left, Vector256<uint> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int64x4_t xvbitsel_v(uint64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> BitwiseSelect(Vector256<long> select, Vector256<long> left, Vector256<long> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint64x4_t xvbitsel_v(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> BitwiseSelect(Vector256<ulong> select, Vector256<ulong> left, Vector256<ulong> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// float32x8_t xvbitsel_v(uint32x8_t a, float32x8_t b, float32x8_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> BitwiseSelect(Vector256<float> select, Vector256<float> left, Vector256<float> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// float64x4_t xvbitsel_v(uint64x4_t a, float64x4_t b, float64x4_t c)
+        ///   LASX: XVBITSEL.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> BitwiseSelect(Vector256<double> select, Vector256<double> left, Vector256<double> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int8x32_t xvabsd_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVABSD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AbsoluteDifference(Vector256<sbyte> left, Vector256<sbyte> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvabsd_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVABSD.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AbsoluteDifference(Vector256<byte> left, Vector256<byte> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int16x16_t xvabsd_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVABSD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AbsoluteDifference(Vector256<short> left, Vector256<short> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvabsd_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVABSD.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AbsoluteDifference(Vector256<ushort> left, Vector256<ushort> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int32x8_t xvabsd_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVABSD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<int> left, Vector256<int> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvabsd_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVABSD.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AbsoluteDifference(Vector256<uint> left, Vector256<uint> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int64x4_t xvabsd_d(uint64x4_t a, int64x4_t b, int64x4_t c)
+        ///   LASX: XVABSD.D Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> AbsoluteDifference(Vector256<long> left, Vector256<long> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvabsd_du(uint64x4_t a, uint64x4_t b, uint64x4_t c)
+        ///   LASX: XVABSD.DU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> AbsoluteDifference(Vector256<ulong> left, Vector256<ulong> right) => AbsoluteDifference(left, right);
+
+        ///// <summary>
+        ///// float32x8_t TODO(float32x8_t a, float32x8_t b)   multi-instructions.
+        /////   LASX: TODO Xd.8S, Xj.8S, Xk.8S
+        ///// </summary>
+        //public static Vector256<float> AbsoluteDifference(Vector256<float> left, Vector256<float> right) => AbsoluteDifference(left, right);
+
+        ///// <summary>
+        ///// float64x4_t TODO(float64x4_t a, float64x4_t b)
+        /////   LASX: TODO Xd.4D, Xj.4D, Xk.4D
+        ///// </summary>
+        //public static Vector256<double> AbsoluteDifference(Vector256<double> left, Vector256<double> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int8x32_t xvld(int8_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// uint8x32_t xvld(uint8_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<byte> LoadVector256(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// int16x16_t xvld(int16_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<short> LoadVector256(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// uint16x16_t xvld(uint16_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadVector256(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// int32x8_t xvld(int32_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<int> LoadVector256(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// uint32x8_t xvld(uint32_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<uint> LoadVector256(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// int64x4_t xvld(int64_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<long> LoadVector256(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// uint64x4_t xvld(uint64_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadVector256(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// float32x8_t xvld(float32_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.8S, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<float> LoadVector256(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// float64x4_t xvld(float64_t const * ptr, const short si12)
+        ///   LASX: XVLD Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<double> LoadVector256(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector256(address, si12);
+
+        /// <summary>
+        /// int8x32_t xvldx(int8_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadVector256(sbyte* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// uint8x32_t xvldx(uint8_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<byte> LoadVector256(byte* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// int16x16_t xvldx(int16_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<short> LoadVector256(short* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// uint16x16_t xvldx(uint16_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadVector256(ushort* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// int32x8_t xvldx(int32_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<int> LoadVector256(int* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// uint32x8_t xvldx(uint32_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<uint> LoadVector256(uint* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// int64x4_t xvldx(int64_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<long> LoadVector256(long* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// uint64x4_t xvldx(uint64_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadVector256(ulong* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// float32x8_t xvldx(float32_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.8S, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<float> LoadVector256(float* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// float64x4_t xvldx(float64_t const * ptr, long offsetValue)
+        ///   LASX: XVLDX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe Vector256<double> LoadVector256(double* address, long offsetValue) => LoadVector256(address, offsetValue);
+
+        /// <summary>
+        /// int8x32_t xvldrepl_b(int8_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.B Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<sbyte> LoadElementReplicateVector(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint8x32_t xvldrepl_b(uint8_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.B Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe Vector256<byte> LoadElementReplicateVector(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// int16x16_t xvldrepl_h(int16_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.H Xd.16H, Rj, si11
+        /// </summary>
+        public static unsafe Vector256<short> LoadElementReplicateVector(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint16x16_t xvldrepl_h(uint16_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.H Xd.16H, Rj, si11
+        /// </summary>
+        public static unsafe Vector256<ushort> LoadElementReplicateVector(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// int32x8_t xvldrepl_w(int32_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.W Xd.8W, Rj, si10
+        /// </summary>
+        public static unsafe Vector256<int> LoadElementReplicateVector(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint32x8_t xvldrepl_w(uint32_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.W Xd.8W, Rj, si10
+        /// </summary>
+        public static unsafe Vector256<uint> LoadElementReplicateVector(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// int64x4_t xvldrepl_d(int64_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.D Xd.4D, Rj, si9
+        /// </summary>
+        public static unsafe Vector256<long> LoadElementReplicateVector(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint64x4_t xvldrepl_d(uint64_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.D Xd.4D, Rj, si9
+        /// </summary>
+        public static unsafe Vector256<ulong> LoadElementReplicateVector(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// float32x8_t vld(float32_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.W Xd.4S, Rj, si10
+        /// </summary>
+        public static unsafe Vector256<float> LoadElementReplicateVector(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// float64x4_t xvldrepl_d(float64_t const * ptr, const short si12)
+        ///   LASX: XVLDREPL.D Xd.4D, Rj, si9
+        /// </summary>
+        public static unsafe Vector256<double> LoadElementReplicateVector(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// float32x8_t xvfrecip_s(float32x8_t a)
+        ///   LASX: XVFRECIP.S Xd.8S Xj.8S
+        /// </summary>
+        public static Vector256<float> Reciprocal(Vector256<float> value) => Reciprocal(value);
+
+        /// <summary>
+        /// float64x4_t xvfrecip_d(float64x4_t a)
+        ///   LASX: XVFRECIP.D Xd.4D Xj.4D
+        /// </summary>
+        public static Vector256<double> Reciprocal(Vector256<double> value) => Reciprocal(value);
+
+        /// <summary>
+        /// float32x8_t xvfrsqrt_s(float32x8_t a)
+        ///   LASX: XVFRSQRT.S Xd.8S Xj.8S
+        /// </summary>
+        public static Vector256<float> ReciprocalSqrt(Vector256<float> value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        /// float64x4_t xvfrsqrt_d(float64x4_t a)
+        ///   LASX: XVFRSQRT.D Xd.4D Xj.4D
+        /// </summary>
+        public static Vector256<double> ReciprocalSqrt(Vector256<double> value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        /// float32x8_t xvfsqrt_s(float32x8_t a)
+        ///   LASX: XVFSQRT.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Sqrt(Vector256<float> value) => Sqrt(value);
+
+        /// <summary>
+        /// float64x4_t xvfsqrt_d(float64x4_t a)
+        ///   LASX: XVFSQRT.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Sqrt(Vector256<double> value) => Sqrt(value);
+
+        /// <summary>
+        /// float32x8_t xvflogb_d(float32x8_t a)
+        ///   LASX: XVFLOGB.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> FloatLogarithm2(Vector256<float> value) => FloatLogarithm2(value);
+
+        /// <summary>
+        /// float64x4_t xvflogb_d(float64x4_t a)
+        ///   LASX: XVFLOGB.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> FloatLogarithm2(Vector256<double> value) => FloatLogarithm2(value);
+
+        /// <summary>
+        /// void xvst(int8x32_t val, int8_t* addr, const short si12)
+        ///   LASX: XVST Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(uint8x32_t val, uint8_t* addr, const short si12)
+        ///   LASX: XVST Xd.32B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(int16x16_t val, int16_t* addr, const short si12)
+        ///   LASX: XVST Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(uint16x16_t val, uint16_t* addr, const short si12)
+        ///   LASX: XVST Xd.16H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(int32x8_t val, int32_t* addr, const short si12)
+        ///   LASX: XVST Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(uint32x8_t val, uint32_t* addr, const short si12)
+        ///   LASX: XVST Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(int64x4_t val, int64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(uint64x4_t val, uint64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(float32x8_t val, float32_t* addr, const short si12)
+        ///   LASX: XVST Xd.8W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvst(float64x4_t val, float64_t* addr, const short si12)
+        ///   LASX: XVST Xd.4D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector256<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void xvstx(int8x32_t val, int8_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<sbyte> vector, sbyte* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(uint8x32_t val, uint8_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.32B, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<byte> vector, byte* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(int16x16_t val, int16_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<short> vector, short* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(uint16x16_t val, uint16_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.16H, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<ushort> vector, ushort* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(int32x8_t val, int32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<int> vector, int* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(uint32x8_t val, uint32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<uint> vector, uint* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(int64x4_t val, int64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<long> vector, long* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(uint64x4_t val, uint64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<ulong> vector, ulong* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(float32x8_t val, float32_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.8W, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<float> vector, float* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstx(float64x4_t val, float64_t* addr, long offsetValue)
+        ///   LASX: XVSTX Xd.4D, Rj, Rk
+        /// </summary>
+        public static unsafe void Store(Vector256<double> vector, double* addr, long offsetValue) => Store(vector, addr, offsetValue);
+
+        /// <summary>
+        /// void xvstelm_b(int8x32_t val, int8_t* addr, const short si8, const byte idx)
+        ///   LASX: XVSTELM.B Xd.32B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(31))] byte idx) => StoreElement(vector, addr, si8, idx);
+
+        /// <summary>
+        /// void xvstelm_b(uint8x32_t val, uint8_t* addr, const short si8, const byte idx)
+        ///   LASX: XVSTELM.B Xd.32B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<byte> vector, byte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(31))] byte idx) => StoreElement(vector, addr, si8, idx);
+
+        /// <summary>
+        /// void xvstelm_h(int16x16_t val, int16_t* addr, const short si9, const byte idx) // Note: si9 is 2byte aligned.
+        ///   LASX: XVSTELM.H Xd.16H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<short> vector, short* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(15))] byte idx) => StoreElement(vector, addr, si9, idx);
+
+        /// <summary>
+        /// void xvstelm_h(uint16x16_t val, uint16_t* addr, const short si9, const byte idx)
+        ///   LASX: XVSTELM.H Xd.16H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<ushort> vector, ushort* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(15))] byte idx) => StoreElement(vector, addr, si9, idx);
+
+        /// <summary>
+        /// void xvstelm_w(int32x8_t val, int32_t* addr, const short si10, const byte idx) // Note: si10 is 4byte aligned.
+        ///   LASX: XVSTELM.W Xd.8W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<int> vector, int* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx) => StoreElement(vector, addr, si10, idx);
+
+        /// <summary>
+        /// void xvstelm_w(uint32x8_t val, uint32_t* addr, const short si10, const byte idx)
+        ///   LASX: XVSTELM.W Xd.8W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<uint> vector, uint* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx) => StoreElement(vector, addr, si10, idx);
+
+        /// <summary>
+ const      /// void xvstelm_d(int64x4_t val, int64_t* addr, const short si11, const byte idx) // Note: si11 is 8byte aligned.
+        ///   LASX: XVSTELM.D Xd.4D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<long> vector, long* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx) => StoreElement(vector, addr, si11, idx);
+
+        /// <summary>
+        /// void xvstelm_d(uint64x4_t val, uint64_t* addr, const short si11, const byte idx)
+        ///   LASX: XVSTELM.D Xd.4D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<ulong> vector, ulong* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx) => StoreElement(vector, addr, si11, idx);
+
+        /// <summary>
+        /// void xvstelm_w(float32x8_t val, float32_t* addr, const short si10, const byte idx)
+        ///   LASX: XVSTELM.W Xd.8S, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<float> vector, float* addr, [ConstantExpected(Min = -512, Max = 511)] short si10, [ConstantExpected(Max = (byte)(7))] byte idx) => StoreElement(vector, addr, si10, idx);
+
+        /// <summary>
+        /// void xvstelm_d(float64x4_t val, float64_t* addr, const short si11, const byte idx)
+        ///   LASX: XVSTELM.D Xd.4D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector256<double> vector, double* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(3))] byte idx) => StoreElement(vector, addr, si11, idx);
+
+        /// <summary>
+        /// int8x32_t xvneg_b(int8x32_t a)
+        ///   LASX: XVNEG.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> Negate(Vector256<sbyte> value) => Negate(value);
+
+        /// <summary>
+        /// int16x16_t xvneg_h(int16x16_t a)
+        ///   LASX: XVNEG.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> Negate(Vector256<short> value) => Negate(value);
+
+        /// <summary>
+        /// int32x8_t xvneg_w(int32x8_t a)
+        ///   LASX: XVNEG.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> Negate(Vector256<int> value) => Negate(value);
+
+        /// <summary>
+        /// int64x4_t xvneg_d(int64x4_t a)
+        ///   LASX: XVNEG.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> Negate(Vector256<long> value) => Negate(value);
+
+        /// <summary>
+        /// float32x8_t xvbitrevi_w(float32x8_t a)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, 31
+        /// </summary>
+        public static Vector256<float> Negate(Vector256<float> value) => Negate(value);
+
+        /// <summary>
+        /// float64x4_t xvbitrevi_d(float64x4_t a)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Negate(Vector256<double> value) => Negate(value);
+
+        /// <summary>
+        /// int16x16_t xvmulwod_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMULWOD.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningOdd(Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmulwod_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMULWOD.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningOdd(Vector256<short> left, Vector256<short> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmulwod_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULWOD.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> MultiplyWideningOdd(Vector256<int> left, Vector256<int> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int128x2_t xvmulwod_q_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMULWOD.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyWideningOdd(Vector256<long> left, Vector256<long> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int16x16_t xvmulwev_h_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVMULWEV.H.B Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> MultiplyWideningEven(Vector256<sbyte> left, Vector256<sbyte> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int32x8_t xvmulwev_w_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVMULWEV.W.H Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<int> MultiplyWideningEven(Vector256<short> left, Vector256<short> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int64x4_t xvmulwev_d_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVMULWEV.D.W Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<long> MultiplyWideningEven(Vector256<int> left, Vector256<int> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int128x2_t xvmulwev_q_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVMULWEV.Q.D Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> MultiplyWideningEven(Vector256<long> left, Vector256<long> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmulwod_hu_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMULWOD.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningOdd(Vector256<byte> left, Vector256<byte> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmulwod_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWOD.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningOdd(Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmulwod_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWOD.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningOdd(Vector256<uint> left, Vector256<uint> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint128x2_t xvmulwod_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMULWOD.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningOdd(Vector256<ulong> left, Vector256<ulong> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvmulwev_hu_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVMULWEV.H.BU Xd.16H, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> MultiplyWideningEven(Vector256<byte> left, Vector256<byte> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvmulwev_wu_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVMULWEV.W.HU Xd.8W, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<uint> MultiplyWideningEven(Vector256<ushort> left, Vector256<ushort> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvmulwev_du_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVMULWEV.D.WU Xd.4D, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningEven(Vector256<uint> left, Vector256<uint> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// uint128x2_t xvmulwev_qu_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVMULWEV.Q.DU Xd.2Q, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> MultiplyWideningEven(Vector256<ulong> left, Vector256<ulong> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// int16x16_t xvmulwod_h_bu(uint8x32_t a, int8x32_t b)
+        // ///   LASX: XVMULWOD.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        // /// </summary>
+        // public static Vector256<short> MultiplyWideningOdd(Vector256<byte> left, Vector256<sbyte> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int32x8_t xvmulwod_w_hu(uint16x16_t a, int16x16_t b)
+        // ///   LASX: XVMULWOD.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        // /// </summary>
+        // public static Vector256<int> MultiplyWideningOdd(Vector256<ushort> left, Vector256<short> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int64x4_t xvmulwod_d_wu(uint32x8_t a, int32x8_t b)
+        // ///   LASX: XVMULWOD.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningOdd(Vector256<uint> left, Vector256<int> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int128x2_t xvmulwod_q_du(uint64x4_t a, int64x4_t b)
+        // ///   LASX: XVMULWOD.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningOdd(Vector256<ulong> left, Vector256<long> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int16x16_t xvmulwev_h_bu(uint8x32_t a, int8x32_t b)
+        // ///   LASX: XVMULWEV.H.BU.B Xd.16H, Xj.32B, Xk.32B
+        // /// </summary>
+        // public static Vector256<short> MultiplyWideningEven(Vector256<byte> left, Vector256<sbyte> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// int32x8_t xvmulwev_w_hu(uint16x16_t a, int16x16_t b)
+        // ///   LASX: XVMULWEV.W.HU.H Xd.8W, Xj.16H, Xk.16H
+        // /// </summary>
+        // public static Vector256<int> MultiplyWideningEven(Vector256<ushort> left, Vector256<short> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// int64x4_t xvmulwev_d_wu(uint32x8_t a, int32x8_t b)
+        // ///   LASX: XVMULWEV.D.WU.W Xd.4D, Xj.8W, Xk.8W
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningEven(Vector256<uint> left, Vector256<int> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// int128x2_t xvmulwev_q_du(uint64x4_t a, int64x4_t b)
+        // ///   LASX: XVMULWEV.Q.DU.D Xd.2Q, Xj.4D, Xk.4D
+        // /// </summary>
+        // public static Vector256<long> MultiplyWideningEven(Vector256<ulong> left, Vector256<long> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int8x32_t xvavg_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVAVG.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Average(Vector256<sbyte> left, Vector256<sbyte> right) => Average(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvavg_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVAVG.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right) => Average(left, right);
+
+        /// <summary>
+        /// int16x16_t xvavg_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVAVG.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> Average(Vector256<short> left, Vector256<short> right) => Average(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvavg_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVAVG.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right) => Average(left, right);
+
+        /// <summary>
+        /// int32x8_t xvavg_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVAVG.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> Average(Vector256<int> left, Vector256<int> right) => Average(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvavg_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAVG.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> Average(Vector256<uint> left, Vector256<uint> right) => Average(left, right);
+
+        /// <summary>
+        /// int64x4_t xvavg_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVAVG.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> Average(Vector256<long> left, Vector256<long> right) => Average(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvavg_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVAVG.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> Average(Vector256<ulong> left, Vector256<ulong> right) => Average(left, right);
+
+        /// <summary>
+        /// int8x32_t xvavgr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVAVGR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AverageRounded(Vector256<sbyte> left, Vector256<sbyte> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvavgr_bu(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVAVGR.BU Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AverageRounded(Vector256<byte> left, Vector256<byte> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int16x16_t xvavgr_h(int16x16_t a, int16x16_t b)
+        ///   LASX: XVAVGR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> AverageRounded(Vector256<short> left, Vector256<short> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvavgr_hu(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVAVGR.HU Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> AverageRounded(Vector256<ushort> left, Vector256<ushort> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int32x8_t xvavgr_w(int32x8_t a, int32x8_t b)
+        ///   LASX: XVAVGR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> AverageRounded(Vector256<int> left, Vector256<int> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvavgr_wu(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAVGR.WU Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> AverageRounded(Vector256<uint> left, Vector256<uint> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int64x4_t xvavgr_d(int64x4_t a, int64x4_t b)
+        ///   LASX: XVAVGR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> AverageRounded(Vector256<long> left, Vector256<long> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvavgr_du(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVAVGR.DU Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> AverageRounded(Vector256<ulong> left, Vector256<ulong> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int16x16_t xvsllwil_h_b(int8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.H.B Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(Vector256<sbyte> value, byte shift) => SignExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvsllwil_h_b(uint8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.H.B Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(Vector256<byte> value, byte shift) => SignExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int32x8_t xvsllwil_w_h(int16x4_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.W.H Xd.8W, Xj.4H, ui4
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(Vector256<short> value, byte shift) => SignExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int32x8_t xvsllwil_w_h(uint16x4_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.W.H Xd.8W, Xj.4H, ui4
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(Vector256<ushort> value, byte shift) => SignExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int64x4_t xvsllwil_d_w(int32x2_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.D.W Xd.4D, Xj.2W, ui5
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(Vector256<int> value, byte shift) => SignExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int64x4_t xvsllwil_d_w(uint32x2_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.D.W Xd.4D, Xj.2W, ui5
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(Vector256<uint> value, byte shift) => SignExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsllwil_hu_bu(uint8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.HU.BU Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<byte> value, byte shift) => ZeroExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvsllwil_hu_bu(int8x32_t a, uint8_t ui3)
+        ///   LASX: XVSLLWIL.HU.BU Xd.16H, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<sbyte> value, byte shift) => ZeroExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsllwil_wu_hu(uint16x16_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.WU.HU Xd.8W, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<ushort> value, byte shift) => ZeroExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int32x8_t xvsllwil_wu_hu(int16x16_t a, uint8_t ui4)
+        ///   LASX: XVSLLWIL.WU.HU Xd.8W, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<short> value, byte shift) => ZeroExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvsllwil_du_wu(uint32x8_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.DU.WU Xd.4D, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<uint> value, byte shift) => ZeroExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// int64x4_t xvsllwil_du_wu(int32x8_t a, uint8_t ui5)
+        ///   LASX: XVSLLWIL.DU.WU Xd.4D, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLowerAndShiftLeftEach128(Vector256<int> value, byte shift) => ZeroExtendWideningLowerAndShiftLeftEach128(value, shift);
+
+        /// <summary>
+        /// uint128x2_t xvextl_qu_du(int64x4_t a)
+        ///   LASX: XVEXTL.QU.DU Xd.2Q, Xj.D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLowerEach128(Vector256<long> value) => ZeroExtendWideningLowerEach128(value);
+
+        /// <summary>
+        /// uint128x2_t xvextl_qu_du(uint64x4_t a)
+        ///   LASX: XVEXTL.QU.DU Xd.2Q, Xj.D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLowerEach128(Vector256<ulong> value) => ZeroExtendWideningLowerEach128(value);
+
+        /// <summary>
+        /// int16x16_t vext2xv_h_b(int8x16_t a)
+        ///   LASX: VEXT2XV.H.B Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLower(Vector128<sbyte> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int16x16_t vext2xv_h_b(uint8x16_t a)
+        ///   LASX: VEXT2XV.H.B Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningLower(Vector128<byte> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_b(int8x8_t a)
+        ///   LASX: VEXT2XV.W.B Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector64<sbyte> value, byte shift) => SignExtendWideningLower(value, shift);
+        //public static Vector256<int> SignExtendWideningLower(Vector128<sbyte> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_b(uint8x8_t a)
+        ///   LASX: VEXT2XV.W.B Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector64<byte> value, byte shift) => SignExtendWideningLower(value, shift);
+        //public static Vector256<int> SignExtendWideningLower(Vector128<byte> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_b(int8x4_t a)
+        ///   LASX: VEXT2XV.D.B Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<sbyte> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_b(uint8x4_t a)
+        ///   LASX: VEXT2XV.D.B Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<byte> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_h(int16x8_t a)
+        ///   LASX: VEXT2XV.W.H Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector128<short> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int32x8_t vext2xv_w_h(uint16x8_t a)
+        ///   LASX: VEXT2XV.W.H Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningLower(Vector128<ushort> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_h(int16x4_t a)
+        ///   LASX: VEXT2XV.D.H Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<short> value, byte shift) => SignExtendWideningLower(value, shift);
+        //public static Vector256<long> SignExtendWideningLower(Vector128<short> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_h(uint16x4_t a)
+        ///   LASX: VEXT2XV.D.H Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector64<ushort> value, byte shift) => SignExtendWideningLower(value, shift);
+        //public static Vector256<long> SignExtendWideningLower(Vector128<ushort> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_w(int32x2_t a)
+        ///   LASX: VEXT2XV.D.W Xd.4D, Xj.2W
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector128<int> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_d_w(uint32x2_t a)
+        ///   LASX: VEXT2XV.D.W Xd.4D, Xj.2W
+        /// </summary>
+        public static Vector256<long> SignExtendWideningLower(Vector128<uint> value, byte shift) => SignExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// uint16x16_t vext2xv_hu_bu(uint8x16_t a)
+        ///   LASX: VEXT2XV.HU.BU Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningLower(Vector128<byte> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int16x16_t vext2xv_hu_bu(int8x16_t a)
+        ///   LASX: VEXT2XV.HU.BU Xd.16H, Xj.16B
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningLower(Vector128<sbyte> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// uint32x8_t vext2xv_wu_bu(uint8x8_t a)
+        ///   LASX: VEXT2XV.WU.BU Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningLower(Vector64<byte> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int32x8_t vext2xv_wu_bu(int8x8_t a)
+        ///   LASX: VEXT2XV.WU.BU Xd.8W, Xj.8B
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// uint64x4_t vext2xv_du_bu(uint8x4_t a)
+        ///   LASX: VEXT2XV.DU.BU Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLower(Vector64<byte> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_du_bu(int8x4_t a)
+        ///   LASX: VEXT2XV.DU.BU Xd.4D, Xj.4B
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// uint32x8_t vext2xv_wu_hu(uint16x8_t a)
+        ///   LASX: VEXT2XV.WU.HU Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningLower(Vector128<ushort> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int32x8_t vext2xv_wu_hu(int16x8_t a)
+        ///   LASX: VEXT2XV.WU.HU Xd.8W, Xj.8H
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningLower(Vector128<short> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// uint64x4_t vext2xv_du_hu(uint16x4_t a)
+        ///   LASX: VEXT2XV.DU.HU Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLower(Vector64<ushort> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_du_hu(int16x4_t a)
+        ///   LASX: VEXT2XV.DU.HU Xd.4D, Xj.4H
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLower(Vector64<short> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// uint64x4_t vext2xv_du_wu(uint32x4_t a)
+        ///   LASX: VEXT2XV.DU.WU Xd.4D, Xj.4W
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningLower(Vector128<uint> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int64x4_t vext2xv_du_wu(int32x4_t a)
+        ///   LASX: VEXT2XV.DU.WU Xd.4D, Xj.4W
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningLower(Vector128<int> value, byte shift) => ZeroExtendWideningLower(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvexth_h_b(int8x32_t a)
+        ///   LASX: XVEXTH.H.B Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> SignExtendWideningUpperEach128(Vector256<sbyte> value) => SignExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int32x8_t xvexth_w_h(int16x16_t a)
+        ///   LASX: XVEXTH.W.H Xd.8W, Xj.16H
+        /// </summary>
+        public static Vector256<int> SignExtendWideningUpperEach128(Vector256<short> value) => SignExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int64x4_t xvexth_d_w(int32x8_t a)
+        ///   LASX: XVEXTH.D.W Xd.4D, Xj.8W
+        /// </summary>
+        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<int> value) => SignExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int128x2_t xvexth_d_w(int64x4_t a)
+        ///   LASX: XVEXTH.Q.D Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<long> SignExtendWideningUpperEach128(Vector256<long> value) => SignExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int16x16_t xvexth_HU_BU(int8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<short> ZeroExtendWideningUpperEach128(Vector256<sbyte> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// uint16x16_t xvexth_HU_BU(uint8x32_t a)
+        ///   LASX: XVEXTH.HU.BU Xd.16H, Xj.32B
+        /// </summary>
+        public static Vector256<ushort> ZeroExtendWideningUpperEach128(Vector256<byte> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int32x8_t xvexth_WU_HU(int16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8W, Xj.16H
+        /// </summary>
+        public static Vector256<int> ZeroExtendWideningUpperEach128(Vector256<short> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// uint32x8_t xvexth_WU_HU(uint16x16_t a)
+        ///   LASX: XVEXTH.WU.HU Xd.8W, Xj.16H
+        /// </summary>
+        public static Vector256<uint> ZeroExtendWideningUpperEach128(Vector256<ushort> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int64x4_t xvexth_DU_WU(uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8W
+        /// </summary>
+        public static Vector256<long> ZeroExtendWideningUpperEach128(Vector256<int> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// uint64x4_t xvexth_DU_WU(uint32x8_t a)
+        ///   LASX: XVEXTH.DU.WU Xd.4D, Xj.8W
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<uint> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int128x2_t xvexth_DU_WU(int64x4_t a)
+        ///   LASX: XVEXTH.QU.DU Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<long> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// uint128x2_t xvexth_DU_WU(uint64x4_t a)
+        ///   LASX: XVEXTH.QU.DU Xd.2Q, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> ZeroExtendWideningUpperEach128(Vector256<ulong> value) => ZeroExtendWideningUpperEach128(value);
+
+        /// <summary>
+        /// int8x32_t xvand_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right) => And(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvand_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right) => And(left, right);
+
+        /// <summary>
+        /// int16x16_t xvand_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> And(Vector256<short> left, Vector256<short> right) => And(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvand_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right) => And(left, right);
+
+        /// <summary>
+        /// int32x8_t xvand_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> And(Vector256<int> left, Vector256<int> right) => And(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvand_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right) => And(left, right);
+
+        /// <summary>
+        /// int64x4_t xvand_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> And(Vector256<long> left, Vector256<long> right) => And(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvand_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right) => And(left, right);
+
+        /// <summary>
+        /// float32x8_t xvand_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> And(Vector256<float> left, Vector256<float> right) => And(left, right);
+
+        /// <summary>
+        /// float64x4_t xvand_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVAND.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> And(Vector256<double> left, Vector256<double> right) => And(left, right);
+
+        /// <summary>
+        /// int8x32_t xvandn_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvandn_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int16x16_t xvandn_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvandn_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int32x8_t xvandn_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvandn_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int64x4_t xvandn_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvandn_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right) => AndNot(left, right);
+
+        /// <summary>
+        /// float32x8_t xvandn_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right) => AndNot(left, right);
+
+        /// <summary>
+        /// float64x4_t xvandn_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVANDN.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int8x32_t xvor_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right) => Or(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvor_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right) => Or(left, right);
+
+        /// <summary>
+        /// int16x16_t xvor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> Or(Vector256<short> left, Vector256<short> right) => Or(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right) => Or(left, right);
+
+        /// <summary>
+        /// int32x8_t xvor_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> Or(Vector256<int> left, Vector256<int> right) => Or(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvor_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right) => Or(left, right);
+
+        /// <summary>
+        /// int64x4_t xvor_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> Or(Vector256<long> left, Vector256<long> right) => Or(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvor_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right) => Or(left, right);
+
+        /// <summary>
+        /// float32x8_t xvor_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> Or(Vector256<float> left, Vector256<float> right) => Or(left, right);
+
+        /// <summary>
+        /// float64x4_t xvor_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> Or(Vector256<double> left, Vector256<double> right) => Or(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvnori_b(uint8x32_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<byte> Not(Vector256<byte> value) => Not(value);
+
+        /// <summary>
+        /// float64x4_t xvnori_b(float64x4_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<double> Not(Vector256<double> value) => Not(value);
+
+        /// <summary>
+        /// int16x16_t xvnori_b(int16x16_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<short> Not(Vector256<short> value) => Not(value);
+
+        /// <summary>
+        /// int32x8_t xvnori_b(int32x8_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<int> Not(Vector256<int> value) => Not(value);
+
+        /// <summary>
+        /// int64x4_t xvnori_b(int64x4_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<long> Not(Vector256<long> value) => Not(value);
+
+        /// <summary>
+        /// int8x32_t xvnori_b(int8x32_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<sbyte> Not(Vector256<sbyte> value) => Not(value);
+
+        /// <summary>
+        /// float32x8_t xvnori_b(float32x8_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<float> Not(Vector256<float> value) => Not(value);
+
+        /// <summary>
+        /// uint16x16_t xvnori_b(uint16x16_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<ushort> Not(Vector256<ushort> value) => Not(value);
+
+        /// <summary>
+        /// uint32x8_t xvnori_b(uint32x8_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// </summary>
+        public static Vector256<uint> Not(Vector256<uint> value) => Not(value);
+
+        /// <summary>
+        /// uint64x4_t xvnori_b(uint64x4_t a)
+        ///   LASX: XVNORI.B Vd.32B, Vj.32B, 0
+        /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
+        /// </summary>
+        public static Vector256<ulong> Not(Vector256<ulong> value) => Not(value);
+
+        /// <summary>
+        /// int8x32_t xvnor_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVNOR.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<sbyte> NotOr(Vector256<sbyte> left, Vector256<sbyte> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvnor_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVNOR.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<byte> NotOr(Vector256<byte> left, Vector256<byte> right) => NotOr(left, right);
+
+        /// <summary>
+        /// int16x16_t xvnor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVNOR.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<short> NotOr(Vector256<short> left, Vector256<short> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvnor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVNOR.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<ushort> NotOr(Vector256<ushort> left, Vector256<ushort> right) => NotOr(left, right);
+
+        /// <summary>
+        /// int32x8_t xvnor_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVNOR.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<int> NotOr(Vector256<int> left, Vector256<int> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvnor_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVNOR.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<uint> NotOr(Vector256<uint> left, Vector256<uint> right) => NotOr(left, right);
+
+        /// <summary>
+        /// int64x4_t xvnor_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVNOR.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<long> NotOr(Vector256<long> left, Vector256<long> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvnor_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVNOR.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<ulong> NotOr(Vector256<ulong> left, Vector256<ulong> right) => NotOr(left, right);
+
+        /// <summary>
+        /// float32x8_t xvnor_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVNOR.V Vd.8S, Vj.8S, Vk.8S
+        /// </summary>
+        public static Vector256<float> NotOr(Vector256<float> left, Vector256<float> right) => NotOr(left, right);
+
+        /// <summary>
+        /// float64x4_t xvnor_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVNOR.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<double> NotOr(Vector256<double> left, Vector256<double> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint8x8_t xvorn(uint8x8_t a, uint8x8_t b)
+        /// </summary>
+        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float64x1_t xvorn(float64x1_t a, float64x1_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int16x4_t xvorn(int16x4_t a, int16x4_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int32x2_t xvorn(int32x2_t a, int32x2_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int64x1_t xvorn(int64x1_t a, int64x1_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int8x8_t xvorn(int8x8_t a, int8x8_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float32x2_t xvorn(float32x2_t a, float32x2_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint16x4_t xvorn(uint16x4_t a, uint16x4_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint32x2_t xvorn(uint32x2_t a, uint32x2_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint64x1_t xvorn(uint64x1_t a, uint64x1_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int8x32_t xvorn_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<sbyte> OrNot(Vector256<sbyte> left, Vector256<sbyte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvorn_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVORN.V Vd.32B, Vj.32B, Vk.32B
+        /// </summary>
+        public static Vector256<byte> OrNot(Vector256<byte> left, Vector256<byte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int16x16_t xvor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVORN.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<short> OrNot(Vector256<short> left, Vector256<short> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVORN.V Vd.16H, Vj.16H, Vk.16H
+        /// </summary>
+        public static Vector256<ushort> OrNot(Vector256<ushort> left, Vector256<ushort> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int32x8_t xvorn_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVORN.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<int> OrNot(Vector256<int> left, Vector256<int> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvorn_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVORN.V Vd.8W, Vj.8W, Vk.8W
+        /// </summary>
+        public static Vector256<uint> OrNot(Vector256<uint> left, Vector256<uint> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int64x4_t xvorn_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVORN.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<long> OrNot(Vector256<long> left, Vector256<long> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvorn_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVORN.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<ulong> OrNot(Vector256<ulong> left, Vector256<ulong> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float32x8_t xvorn_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVORN.V Vd.8S, Vj.8S, Vk.8S
+        /// </summary>
+        public static Vector256<float> OrNot(Vector256<float> left, Vector256<float> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float64x4_t xvorn_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVORN.V Vd.4D, Vj.4D, Vk.4D
+        /// </summary>
+        public static Vector256<double> OrNot(Vector256<double> left, Vector256<double> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int8x32_t xvxor_v(int8x32_t a, int8x32_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint8x32_t xvxor_v(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right) => Xor(left, right);
+
+        /// <summary>
+        /// int16x16_t xvxor_v(int16x16_t a, int16x16_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint16x16_t xvxor_v(uint16x16_t a, uint16x16_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right) => Xor(left, right);
+
+        /// <summary>
+        /// int32x8_t xvxor_v(int32x8_t a, int32x8_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint32x8_t xvxor_v(uint32x8_t a, uint32x8_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right) => Xor(left, right);
+
+        /// <summary>
+        /// int64x4_t xvxor_v(int64x4_t a, int64x4_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint64x4_t xvxor_v(uint64x4_t a, uint64x4_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right) => Xor(left, right);
+
+        /// <summary>
+        /// float32x8_t xvxor_v(float32x8_t a, float32x8_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right) => Xor(left, right);
+
+        /// <summary>
+        /// float64x4_t xvxor_v(float64x4_t a, float64x4_t b)
+        ///   LASX: XVXOR.V Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right) => Xor(left, right);
+
+        /// <summary>
+        /// int8x32_t xvslli_b(int8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvslli_b(uint8x32_t a, const int n)
+        ///   LASX: XVSLLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvslli_h(int16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvslli_h(uint16x16_t a, const int n)
+        ///   LASX: XVSLLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvslli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvslli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSLLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int64x4_t xvslli_d(int64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvslli_d(uint64x4_t a, const int n)
+        ///   LASX: XVSLLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvbsll_v(int8x32_t a, const int shift)
+        ///   LASX: XVBSLL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogicalByByteEach128(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftLogicalByByteEach128(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvbsll_v(uint8x32_t a, const int shift)
+        ///   LASX: XVBSLL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogicalByByteEach128(Vector256<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftLogicalByByteEach128(value, shift);
+
+        /// int8x32_t xvsll_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSLL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftLeftLogical(Vector256<sbyte> value, Vector256<sbyte> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsll_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSLL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> ShiftLeftLogical(Vector256<byte> value, Vector256<byte> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int16x16 xvsll_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSLL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftLeftLogical(Vector256<short> value, Vector256<short> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint16x16 xvsll_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSLL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, Vector256<ushort> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int32x8 xvsll_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSLL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftLeftLogical(Vector256<int> value, Vector256<int> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8 xvsll_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSLL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, Vector256<uint> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int64x4 xvsll_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSLL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftLeftLogical(Vector256<long> value, Vector256<long> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint64x4 xvsll_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSLL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, Vector256<ulong> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrli_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsrli_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsrli_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvsrli_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvbsrl_v(int8x32_t a, const int shift)
+        ///   LASX: XVBSRL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalByByteEach128(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalByByteEach128(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvbsrl_v(uint8x32_t a, const int shift)
+        ///   LASX: XVBSRL.V Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalByByteEach128(Vector256<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalByByteEach128(value, shift);
+
+        /// int8x32_t xvsrl_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSRL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogical(Vector256<sbyte> value, Vector256<sbyte> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrl_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSRL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogical(Vector256<byte> value, Vector256<byte> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int16x16 xvsrl_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightLogical(Vector256<short> value, Vector256<short> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x16 xvsrl_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int32x8 xvsrl_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector256<int> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x8 xvsrl_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int64x4 xvsrl_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightLogical(Vector256<long> value, Vector256<long> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint64x4 xvsrl_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrlri_b(uint8x32_t a, const int n)
+        ///   LASX: XVSRLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsrlri_h(uint16x16_t a, const int n)
+        ///   LASX: XVSRLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsrlri_w(uint32x8_t a, const int n)
+        ///   LASX: XVSRLRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvsrlri_d(uint64x4_t a, const int n)
+        ///   LASX: XVSRLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrlr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSRLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRounded(Vector256<sbyte> value, Vector256<sbyte> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrlr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVSRLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRounded(Vector256<byte> value, Vector256<byte> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int16x16 xvsrlr_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRounded(Vector256<short> value, Vector256<short> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint16x16 xvsrlr_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRounded(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int32x8 xvsrlr_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRounded(Vector256<int> value, Vector256<int> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint32x8 xvsrlr_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRounded(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int64x4 xvsrlr_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightLogicalRounded(Vector256<long> value, Vector256<long> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint64x4 xvsrlr_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> ShiftRightLogicalRounded(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvsrlrni_b_h(uint16x16_t left, uint16x16_t right, const int n)
+        ///   LASX: XVSRLRNI.B.H Xd, Xj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrlrni_b_h(int16x16_t left, int16x16_t right, const int n)
+        ///   LASX: XVSRLRNI.B.H Xd, Xj, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvsrlrni_h_w(int32x8_t left, int32x8_t right, const int n)
+        ///   LASX: XVSRLRNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvsrlrni_h_w(uint32x8_t left, uint32x8_t right, const int n)
+        ///   LASX: XVSRLRNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvsrlrni_w_d(int64x4_t left, int64x4_t right, const int n)
+        ///   LASX: XVSRLRNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvsrlrni_w_d(uint64x4_t left, uint64x4_t right, const int n)
+        ///   LASX: XVSRLRNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvsrlrni_d_q(int128x2_t left, int128x2_t right, const int n)
+        /////   LASX: XVSRLRNI.D.Q Xd, Xj, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvsrlrn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint8x16_t xvsrlrn_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x8_t xvsrlrn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x8_t xvsrlrn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvsrlrn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvsrlrn_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int8x16_t xvsrarni_b_h(int16x16_t left, int16x16_t right, const int n)
+        ///   LASX: XVSRARNI.B.H Xd, Xj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvsrarni_h_w(int32x8_t left, int32x8_t right, const int n)
+        ///   LASX: XVSRARNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvsrarni_w_d(int64x4_t left, int64x4_t right, const int n)
+        ///   LASX: XVSRARNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvsrarni_d_q(int128x2_t left, int128x2_t right, const int n)
+        /////   LASX: XVSRARNI.D.Q Xd, Xj, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvsrarn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRARN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x8_t xvsrarn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRARN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x8_t xvsrarn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRARN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvsrarn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRARN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticRoundedNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrai_b(int8x32_t a, const int n)
+        ///   LASX: XVSRAI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvsrai_h(int16x16_t a, const int n)
+        ///   LASX: XVSRAI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int32x8_t xvsrai_w(int32x8_t a, const int n)
+        ///   LASX: XVSRAI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int64x4_t xvsrai_d(int64x4_t a, const int n)
+        ///   LASX: XVSRAI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int8x32_txvsra_b(int8x32_t a, int8x32_t b)
+        ///   LASX:  XVSRA.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmetic(Vector256<sbyte> value, Vector256<sbyte> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int16x16xvsra_h(int16x16_t value, int16x16_t shift)
+        ///   LASX:  XVSRA.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int32x8xvsra_w(int32x8_t value, int32x8_t shift)
+        ///   LASX:  XVSRA.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int64x4xvsra_d(int64x4_t value, int64x4_t shift)
+        ///   LASX:  XVSRA.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmetic(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrari_b(int8x32_t a, const int n)
+        ///   LASX: XVSRARI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvsrari_h(int16x16_t a, const int n)
+        ///   LASX: XVSRARI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int32x8_t xvsrari_w(int32x8_t a, const int n)
+        ///   LASX: XVSRARI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int64x4_t xvsrari_d(int64x4_t a, const int n)
+        ///   LASX: XVSRARI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsrar_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVSRAR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRounded(Vector256<sbyte> value, Vector256<sbyte> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int16x16 xvsrar_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSRAR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRounded(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int32x8 xvsrar_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRAR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRounded(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int64x4 xvsrar_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRAR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> ShiftRightArithmeticRounded(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvrotri_b(uint8x32_t a, const int n)
+        ///   LASX: XVROTRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> RotateRight(Vector256<sbyte> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvrotri_b(uint8x32_t a, const int n)
+        ///   LASX: XVROTRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> RotateRight(Vector256<byte> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvrotri_h(uint16x16_t a, const int n)
+        ///   LASX: XVROTRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> RotateRight(Vector256<short> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvrotri_h(uint16x16_t a, const int n)
+        ///   LASX: XVROTRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> RotateRight(Vector256<ushort> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvrotri_w(uint32x8_t a, const int n)
+        ///   LASX: XVROTRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> RotateRight(Vector256<int> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x8_t xvrotri_w(uint32x8_t a, const int n)
+        ///   LASX: XVROTRI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> RotateRight(Vector256<uint> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvrotri_d(uint64x4_t a, const int n)
+        ///   LASX: XVROTRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> RotateRight(Vector256<long> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x4_t xvrotri_d(uint64x4_t a, const int n)
+        ///   LASX: XVROTRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> RotateRight(Vector256<ulong> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvrotr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVROTR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> RotateRight(Vector256<sbyte> value, Vector256<sbyte> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint8x32_t xvrotr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVROTR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> RotateRight(Vector256<byte> value, Vector256<byte> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int16x16 xvrotr_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVROTR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> RotateRight(Vector256<short> value, Vector256<short> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint16x16 xvrotr_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVROTR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> RotateRight(Vector256<ushort> value, Vector256<ushort> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int32x8 xvrotr_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVROTR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> RotateRight(Vector256<int> value, Vector256<int> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x8 xvrotr_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVROTR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> RotateRight(Vector256<uint> value, Vector256<uint> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int64x4 xvrotr_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVROTR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> RotateRight(Vector256<long> value, Vector256<long> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x4 xvrotr_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVROTR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> RotateRight(Vector256<ulong> value, Vector256<ulong> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvsigncov_b(int8x32_t a)
+        ///   LASX: XVSIGNCOV.B Xd.32B, Xj.32B, Xj.32B
+        /// </summary>
+        public static Vector256<byte> Abs(Vector256<sbyte> value) => Abs(value);
+
+        /// <summary>
+        /// int16x16_t xvsigncov_h(int16x16_t a)
+        ///   LASX: XVSIGNCOV.H Xd.16H, Xj.16H, Xj.16H
+        /// </summary>
+        public static Vector256<ushort> Abs(Vector256<short> value) => Abs(value);
+
+        /// <summary>
+        /// int32x8_t xvsigncov_w(int32x8_t a)
+        ///   LASX: XVSIGNCOV.W Xd.8W, Xj.8W, Xj.8W
+        /// </summary>
+        public static Vector256<uint> Abs(Vector256<int> value) => Abs(value);
+
+        /// <summary>
+        /// int64x4_t xvsigncov_d(int64xx_t a)
+        ///   LASX: XVSIGNCOV.D Xd.4D, Xj.4D, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> Abs(Vector256<long> value) => Abs(value);
+
+        /// <summary>
+        /// float32x8_t xvbitclri_w(float32x8_t a)
+        ///   LASX: XVBITCLRI.W Xd.8S, Xd.8S, 31
+        /// </summary>
+        public static Vector256<float> Abs(Vector256<float> value) => Abs(value);
+
+        /// <summary>
+        /// float64x4_t xvbitclri_d(float64x4_t a)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, 63
+        /// </summary>
+        public static Vector256<double> Abs(Vector256<double> value) => Abs(value);
+
+        /// <summary>
+        /// float32x8_t xvfrintrm_s(float32x8_t a)
+        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Floor(Vector256<float> value) => Floor(value);
+
+        /// <summary>
+        /// float64x4_t xvfrintrm_d(float64x4_t a)
+        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Floor(Vector256<double> value) => Floor(value);
+
+        /// <summary>
+        /// float32x8_t xvfrintrp_s(float32x8_t a)
+        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> Ceiling(Vector256<float> value) => Ceiling(value);
+
+        /// <summary>
+        /// float64x4_t xvfrintrp_d(float64x4_t a)
+        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> Ceiling(Vector256<double> value) => Ceiling(value);
+
+        /// <summary>
+        /// float32x8_t xvfrintrz_s(float32x8_t a)
+        ///   LASX: XVFRINTRZ.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> RoundToZero(Vector256<float> value) => RoundToZero(value);
+
+        /// <summary>
+        /// float64x4_t xvfrintrz_d(float64x4_t a)
+        ///   LASX: XVFRINTRZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToZero(Vector256<double> value) => RoundToZero(value);
+
+        /// <summary>
+        /// float32x8_t xvfrintrm_s(float32x8_t a)
+        ///   LASX: XVFRINTRM.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value) => RoundToNegativeInfinity(value);
+
+        /// <summary>
+        /// float64x4_t xvfrintrm_d(float64x4_t a)
+        ///   LASX: XVFRINTRM.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value) => RoundToNegativeInfinity(value);
+
+        /// <summary>
+        /// float32x8_t xvfrintrp_s(float32x8_t a)
+        ///   LASX: XVFRINTRP.S Xd.8S, Xj.8S
+        /// </summary>
+        public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value) => RoundToPositiveInfinity(value);
+
+        /// <summary>
+        /// float64x4_t xvfrintrp_d(float64x4_t a)
+        ///   LASX: XVFRINTRP.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value) => RoundToPositiveInfinity(value);
+
+        // /// <summary>
+        // /// int8x32_t TODO(int8x32_t v, int8_t data, const int index)  NOTE: maybe implemented by two instructions.
+        // ///   LASX: TODO Xd.B, Rj, imm
+        // /// </summary>
+        // public static Vector256<sbyte> Insert(Vector256<sbyte> vector, sbyte data, const byte index) => Insert(vector, data, index);
+
+        // /// <summary>
+        // /// uint8x32_t TODO(uint8x32_t v, uint8_t data, const int index)  NOTE: maybe implemented by two instructions.
+        // ///   LASX: TODO Xd.B, Rj, imm
+        // /// </summary>
+        // public static Vector256<byte> Insert(Vector256<byte> vector, byte data, const byte index) => Insert(vector, data, index);
+
+        // /// <summary>
+        // /// int16x16_t TODO(int16x16_t v, int16_t data, const int index)  NOTE: maybe implemented by two instructions.
+        // ///   LASX: TODO Xd.H, Rj, imm
+        // /// </summary>
+        // public static Vector256<short> Insert(Vector256<short> vector, short data, const byte index) => Insert(vector, data, index);
+
+        // /// <summary>
+        // /// uint16x16_t TODO(uint16x16_t v, uint16_t data, const int index)  NOTE: maybe implemented by two instructions.
+        // ///   LASX: TODO Xd.H, Rj, imm
+        // /// </summary>
+        // public static Vector256<ushort> Insert(Vector256<ushort> vector, ushort data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int32x8_t xvinsgr2vr_w(int32x8_t v, int32_t data, const int index)
+        ///   LASX: XVINSGR2VR.W Xd.S, Rj, ui3
+        /// </summary>
+        public static Vector256<int> Insert(Vector256<int> vector, int data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// uint32x8_t xvinsgr2vr_w(uint32x8_t v, uint32_t data, const int index)
+        ///   LASX: XVINSGR2VR.W Xd.S, Rj, ui3
+        /// </summary>
+        public static Vector256<uint> Insert(Vector256<uint> vector, uint data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int64x4_t xvinsgr2vr_d(int64x4_t v, int64_t data, const int index)
+        ///   LASX: XVINSGR2VR.D Xd.D, Rj, ui2
+        /// </summary>
+        public static Vector256<long> Insert(Vector256<long> vector, long data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// uint64x4_t xvinsgr2vr_d(uint64x4_t v, uint64_t data, const int index)
+        ///   LASX: XVINSGR2VR.D Xd.D, Rj, ui2
+        /// </summary>
+        public static Vector256<ulong> Insert(Vector256<ulong> vector, ulong data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// float32x8_t xvinsve0_w(float32x8_t v, float32_t data, const int index)
+        ///   LASX: XVINSVE0.W Xd.S, Xj.S[0], ui3
+        /// </summary>
+        public static Vector256<float> Insert(Vector256<float> vector, float data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// float64x4_t xvinsve0_d(float64x4_t v, float64_t data, const int index)
+        ///   LASX: XVINSVE0.D Xd.D, Xj.D[0], ui2
+        /// </summary>
+        public static Vector256<double> Insert(Vector256<double> vector, double data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int8x32_t xvreplgr2vr_b(int8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// </summary>
+        public static Vector256<sbyte> DuplicateToVector256(sbyte value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint8x32_t xvreplgr2vr_b(uint8_t value)
+        ///   LASX: XVREPLGR2VR.B Xd.32B, Rj
+        /// </summary>
+        public static Vector256<byte> DuplicateToVector256(byte value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// int16x16_t xvreplgr2vr_h(int16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// </summary>
+        public static Vector256<short> DuplicateToVector256(short value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint16x16_t xvreplgr2vr_h(uint16_t value)
+        ///   LASX: XVREPLGR2VR.H Xd.16H, Rj
+        /// </summary>
+        public static Vector256<ushort> DuplicateToVector256(ushort value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// int32x8_t xvreplgr2vr_w(int32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8W, Rj
+        /// </summary>
+        public static Vector256<int> DuplicateToVector256(int value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint32x8_t xvreplgr2vr_w(uint32_t value)
+        ///   LASX: XVREPLGR2VR.W Xd.8W, Rj
+        /// </summary>
+        public static Vector256<uint> DuplicateToVector256(uint value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// int64x4_t xvreplgr2vr_d(int64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// </summary>
+        public static Vector256<long> DuplicateToVector256(long value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// uint64x4_t xvreplgr2vr_d(uint64_t value)
+        ///   LASX: XVREPLGR2VR.D Xd.4D, Rj
+        /// </summary>
+        public static Vector256<ulong> DuplicateToVector256(ulong value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// float32x8_t xvreplve0_w(float32_t value)
+        ///   LASX: XVREPLVE0.W Xd.8S, Xj.S[0]
+        /// </summary>
+        public static Vector256<float> DuplicateToVector256(float value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// float64x4_t xvreplve0_d(float64_t value)
+        ///   LASX: XVREPLVE0.D Xd.4D, Xj.D[0]
+        /// </summary>
+        public static Vector256<double> DuplicateToVector256(double value) => DuplicateToVector256(value);
+
+        /// <summary>
+        /// float32x8_t xvffint_s_w(int32x8_t a)
+        ///   LASX: XVFFINT.S.W Xd.8S, Xj.8W
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<int> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float32x8_t xvffint_s_wu(uint32x8_t a)
+        ///   LASX: XVFFINT.S.WU Xd.8S, Xj.8W
+        /// </summary>
+        public static Vector256<float> ConvertToSingle(Vector256<uint> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float64x4_t xvffint_d_l(int64x4_t a)
+        ///   LASX: XVFFINT.D.L Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> ConvertToDouble(Vector256<long> value) => ConvertToDouble(value);
+
+        /// <summary>
+        /// float64x4_t xvffint_d_lu(uint64x4_t a)
+        ///   LASX: XVFFINT.D.LU Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<double> ConvertToDouble(Vector256<ulong> value) => ConvertToDouble(value);
+
+        /// <summary>
+        /// bool xvsetnez_v(uint8x32_t value)
+        ///   LASX: XVSETNEZ.V cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector256<byte> value) => HasElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvseteqz_v(uint8x32_t value)
+        ///   LASX: XVSETEQZ.V cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector256<byte> value) => AllElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_b(int8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<sbyte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_b(uint8x32_t value)
+        ///   LASX: XVSETALLNEZ.B cd, Xj.32B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<byte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_h(int16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<short> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_h(uint16x16_t value)
+        ///   LASX: XVSETALLNEZ.H cd, Xj.16H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ushort> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w(int32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<int> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w(uint32x8_t value)
+        ///   LASX: XVSETALLNEZ.W cd, Xj.8W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<uint> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w(int64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<long> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetallnez_w(uint64x8_t value)
+        ///   LASX: XVSETALLNEZ.D cd, Xj.4D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector256<ulong> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_b(int8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<sbyte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_b(uint8x32_t value)
+        ///   LASX: XVSETANYEQZ.B cd, Xj.32B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<byte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_h(int16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<short> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_h(uint16x16_t value)
+        ///   LASX: XVSETANYEQZ.H cd, Xj.16H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ushort> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(int32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<int> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(uint32x8_t value)
+        ///   LASX: XVSETANYEQZ.W cd, Xj.8W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<uint> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(int64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<long> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool xvsetanyeqz_w(uint64x8_t value)
+        ///   LASX: XVSETANYEQZ.D cd, Xj.4D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector256<ulong> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// int8x32 xvsrlni_b_h(int16x16_t left, int16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingLowerEach128(Vector256<short> left, Vector256<short> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint8x32 xvsrlni_b_h(uint16x16_t left, uint16x16_t right, shift)
+        ///   LASX: XVSRLNI.B.H Xd, Xj, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> left, Vector256<ushort> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16 xvsrlni_h_w(int32x8_t left, int32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> left, Vector256<int> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16 xvsrlni_h_w(uint32x8_t left, uint32x8_t right, shift)
+        ///   LASX: XVSRLNI.H.W Xd, Xj, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> left, Vector256<uint> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8 xvsrlni_w_d(int64x4_t left, int64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> left, Vector256<long> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8 xvsrlni_w_d(uint64x4_t left, uint64x4_t right, shift)
+        ///   LASX: XVSRLNI.W.D Xd, Xj, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> left, Vector256<ulong> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x4 xvsrlni_d_q(uint128x2_t left, uint128x2_t right, shift)
+        /////   LASX: XVSRLNI.D.Q Xd.2Q, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, byte shift) => ShiftRightLogicalNarrowingLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint8x16_t xvsrln_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSRLN.B.H Xd.8B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x8_t xvsrln_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightLogicalNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x8_t xvsrln_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvsrln_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSRLN.W.D Xd.4W, Xj.4D, Xk.2D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightLogicalNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvsrln_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSRLN.W.D Xd.4W, Xj.4D, Xk.2D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalNarrowingLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x8_t xvssrlni_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRLNI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrlni_b_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLNI.B.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvssrlni_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRLNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlni_h_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvssrlni_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRLNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrlni_w_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvssrlni_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRLNI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvssrln_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRLN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint8x16_t xvssrln_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x4_t xvssrln_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x4_t xvssrln_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvssrln_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRLN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvssrln_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlni_bu_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLNI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlni_hu_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLNI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrlni_wu_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLNI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x4_t xvssrlni_du_q(uint128x2_t left, uint128x2_t right, const byte n)
+        /////   LASX: XVSSRLNI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint8x16_t xvssrln_bu_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x4_t xvssrln_hu_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvssrln_wu_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvssran_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRANI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvssran_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRANI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvssran_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRANI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvssran_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRANI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvssran_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRAN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x4_t xvssran_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRAN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvssran_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRAN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrani_bu_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRANI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrani_hu_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRANI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrani_wu_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRANI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x4_t xvssrani_du_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRANI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint8x16_t xvssran_bu_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRAN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x4_t xvssran_hu_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRAN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvssran_wu_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRAN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvssrlrni_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRLRNI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_b_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLRNI.B.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvssrlrni_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRLRNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_h_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLRNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvssrlrni_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRLRNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrlrni_w_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLRNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvssrlrni_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRLRNI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvssrlrn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint8x16_t xvssrlrn_b_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLRN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x4_t xvssrlrn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x4_t xvssrlrn_h_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLRN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvssrlrn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvssrlrn_w_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLRN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_bu_h(uint16x16_t left, uint16x16_t right, const byte n)
+        ///   LASX: XVSSRLRNI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> left, Vector256<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrlrni_hu_w(uint32x8_t left, uint32x8_t right, const byte n)
+        ///   LASX: XVSSRLRNI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> left, Vector256<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrlrni_wu_d(uint64x4_t left, uint64x4_t right, const byte n)
+        ///   LASX: XVSSRLRNI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> left, Vector256<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x4_t xvssrlrni_du_q(uint128x2_t left, uint128x2_t right, const byte n)
+        /////   LASX: XVSSRLRNI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulonglong> left, Vector256<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint8x16_t xvssrlrn_bu_h(uint16x16_t value, uint16x16_t shift)
+        ///   LASX: XVSSRLRN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ushort> value, Vector256<ushort> shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x4_t xvssrlrn_hu_w(uint32x8_t value, uint32x8_t shift)
+        ///   LASX: XVSSRLRN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<uint> value, Vector256<uint> shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvssrlrn_wu_d(uint64x4_t value, uint64x4_t shift)
+        ///   LASX: XVSSRLRN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<ulong> value, Vector256<ulong> shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x16_t xvssrarn_b_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRARNI.B.H Xd.32B, Xj.16H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int16x16_t xvssrarn_h_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRARNI.H.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int32x8_t xvssrarn_w_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRARNI.W.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// int64x4_t xvssrarn_d_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRARNI.D.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<long> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t xvssrarn_b_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRARN.B.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int16x4_t xvssrarn_h_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRARN.H.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// int32x4_t xvssrarn_w_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRARN.W.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrarni_bu_h(int16x16_t left, int16x16_t right, const byte n)
+        ///   LASX: XVSSRARNI.BU.H Xd.32B, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> left, Vector256<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint16x16_t xvssrarni_hu_w(int32x8_t left, int32x8_t right, const byte n)
+        ///   LASX: XVSSRARNI.HU.W Xd.16H, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> left, Vector256<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint32x8_t xvssrarni_wu_d(int64x4_t left, int64x4_t right, const byte n)
+        ///   LASX: XVSSRARNI.WU.D Xd.8W, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> left, Vector256<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x4_t xvssrarni_du_q(int128x2_t left, int128x2_t right, const byte n)
+        /////   LASX: XVSSRARNI.DU.Q Xd.4D, Xj.2Q, ui7
+        ///// </summary>
+        //public static Vector256<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<longlong> left, Vector256<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(left, right, shift);
+
+        /// <summary>
+        /// uint8x16_t xvssrarn_bu_h(int16x16_t value, int16x16_t shift)
+        ///   LASX: XVSSRARN.BU.H Xd.16B, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<short> value, Vector256<short> shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint16x8_t xvssrarn_hu_w(int32x8_t value, int32x8_t shift)
+        ///   LASX: XVSSRARN.HU.W Xd.8H, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<int> value, Vector256<int> shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// uint32x4_t xvssrarn_wu_d(int64x4_t value, int64x4_t shift)
+        ///   LASX: XVSSRARN.WU.D Xd.4W, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(Vector256<long> value, Vector256<long> shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(value, shift);
+
+        /// <summary>
+        /// int8x32_t xvclo_b(int8x32_t a)
+        ///   LASX: XVCLO.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> LeadingSignCount(Vector256<sbyte> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int16x16_t xvclo_h(int16x16_t a)
+        ///   LASX: XVCLO.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> LeadingSignCount(Vector256<short> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int32x8_t xvclo_w(int32x8_t a)
+        ///   LASX: XVCLO.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> LeadingSignCount(Vector256<int> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int64x4_t xvclo_d(int64x4_t a)
+        ///   LASX: XVCLO.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> LeadingSignCount(Vector256<long> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int8x32_t xvclz_b(int8x32_t a)
+        ///   LASX: XVCLZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<sbyte> LeadingZeroCount(Vector256<sbyte> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint8x32_t xvclz_b(uint8x32_t a)
+        ///   LASX: XVCLZ.B Xd.32B, Xj.32B
+        /// </summary>
+        public static Vector256<byte> LeadingZeroCount(Vector256<byte> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int16x16_t xvclz_h(int16x16_t a)
+        ///   LASX: XVCLZ.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<short> LeadingZeroCount(Vector256<short> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint16x16_t xvclz_h(uint16x16_t a)
+        ///   LASX: XVCLZ.H Xd.16H, Xj.16H
+        /// </summary>
+        public static Vector256<ushort> LeadingZeroCount(Vector256<ushort> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int32x8_t xvclz_w(int32x8_t a)
+        ///   LASX: XVCLZ.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<int> LeadingZeroCount(Vector256<int> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint32x8_t xvclz_w(uint32x8_t a)
+        ///   LASX: XVCLZ.W Xd.8W, Xj.8W
+        /// </summary>
+        public static Vector256<uint> LeadingZeroCount(Vector256<uint> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int64x4_t xvclz_d(int64x4_t a)
+        ///   LASX: XVCLZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<long> LeadingZeroCount(Vector256<long> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint64x4_t xvclz_d(uint64x4_t a)
+        ///   LASX: XVCLZ.D Xd.4D, Xj.4D
+        /// </summary>
+        public static Vector256<ulong> LeadingZeroCount(Vector256<ulong> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int8x32_t xvpcnt_b(int8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<sbyte> PopCount(Vector256<sbyte> value) => PopCount(value);
+
+        /// <summary>
+        /// uint8x32_t xvpcnt_b(uint8x32_t a)
+        ///   LASX: XVPCNT_B Xd, Xj
+        /// </summary>
+        public static Vector256<byte> PopCount(Vector256<byte> value) => PopCount(value);
+
+        /// <summary>
+        /// int16x16_t xvpcnt_h(int16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<short> PopCount(Vector256<short> value) => PopCount(value);
+
+        /// <summary>
+        /// uint16x16_t xvpcnt_h(uint16x16_t a)
+        ///   LASX: XVPCNT_H Xd, Xj
+        /// </summary>
+        public static Vector256<ushort> PopCount(Vector256<ushort> value) => PopCount(value);
+
+        /// <summary>
+        /// int32x8_t xvpcnt_w(int32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<int> PopCount(Vector256<int> value) => PopCount(value);
+
+        /// <summary>
+        /// uint32x8_t xvpcnt_w(uint32x8_t a)
+        ///   LASX: XVPCNT_W Xd, Xj
+        /// </summary>
+        public static Vector256<uint> PopCount(Vector256<uint> value) => PopCount(value);
+
+        /// <summary>
+        /// int64x4_t xvpcnt_d(int64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<long> PopCount(Vector256<long> value) => PopCount(value);
+
+        /// <summary>
+        /// uint64x4_t xvpcnt_d(uint64x4_t a)
+        ///   LASX: XVPCNT_D Xd, Xj
+        /// </summary>
+        public static Vector256<ulong> PopCount(Vector256<ulong> value) => PopCount(value);
+
+        /// <summary>
+        ///  int32x8_t xvperm_w(int32x8_t vec, int32x8_t idx)
+        ///   LASX: XVPERM.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorShuffle(Vector256<int> vector, Vector256<int> indexs) => VectorShuffle(vector, indexs);
+
+        /// <summary>
+        ///  uint32x8_t xvperm_w(uint32x8_t vec, uint32x8_t idx)
+        ///   LASX: XVPERM.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorShuffle(Vector256<uint> vector, Vector256<uint> indexs) => VectorShuffleEach128(vector, indexs);
+
+        /// <summary>
+        ///  int64x4_t xvpermi_w(int64x4_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector256<long> VectorShuffle(Vector256<long> vector, const byte indexs) => VectorShuffle(vector, indexs);
+
+        /// <summary>
+        ///  uint64x4_t xvpermi_w(uint64x4_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector256<ulong> VectorShuffle(Vector256<ulong> vector, const byte indexs) => VectorShuffleEach128(vector, indexs);
+
+        /// <summary>
+        ///  int128x2_t xvpermi_w(int128x2_t vec0, int128x2_t vec1, uint8_t idx)
+        ///   LASX: XVPERMI.D Xd.2Q, Xj.2Q, ui8                    ///NOTE: The Xd is both input and output.
+        /// </summary>
+        public static Vector256<long> VectorShuffle(Vector256<long> vector0, Vector256<long> vector1, const byte indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        ///// <summary>
+        /////  uint8x32_t xvshuf_b(uint8x32_t vec, uint8x32_t idx)
+        /////   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        ///// </summary>
+        //public static Vector256<byte> VectorShuffleEach128(Vector256<byte> vector, Vector256<byte> indexs) => VectorShuffleEach128(vector, indexs);
+
+        ///// <summary>
+        /////  int8x32_t xvshuf_b(int8x32_t vec, int8x32_t idx)
+        /////   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        ///// </summary>
+        //public static Vector256<sbyte> VectorShuffleEach128(Vector256<sbyte> vector, Vector256<sbyte> indexs) => VectorShuffleEach128(vector, indexs);
+
+        /// <summary>
+        ///  uint8x32_t xvshuf_b(uint8x32_t vec0, uint8x32_t vec1, uint8x32_t idx)
+        ///   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        /// </summary>
+        public static Vector256<byte> VectorShuffleEach128(Vector256<byte> vector0, Vector256<byte> vector1, Vector256<byte> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int8x32_t xvshuf_b(int8x32_t vec0, int8x32_t vec1, int8x32_t idx)
+        ///   LASX: XVSHUF.B Xd.32B, Xj.32B, Xk.32B, Xa.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorShuffleEach128(Vector256<sbyte> vector0, Vector256<sbyte> vector1, Vector256<sbyte> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        ///// <summary>
+        /////  int16x16_t xvshuf_h(int16x16_t vec, int16x16_t idx)
+        /////   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H                //NOTE: Xd is both input and output while input as index.
+        ///// </summary>
+        //public static Vector256<short> VectorShuffleEach128(Vector256<short> vector, Vector256<short> indexs) => VectorShuffleEach128(vector, indexs);
+
+        ///// <summary>
+        /////  uint16x16_t xvshuf_h(uint16x16_t vec, uint16x16_t idx)
+        /////   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H                                //NOTE: Xd is both input and output while input as index.
+        ///// </summary>
+        //public static Vector256<ushort> VectorShuffleEach128(Vector256<ushort> vector, Vector256<ushort> indexs) => VectorShuffleEach128(vector, indexs);
+
+        /// <summary>
+        ///  int16x16_t xvshuf_h(int16x16_t vec0, int16x16_t vec1, int16x16_t idx)
+        ///   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H                                //NOTE: Xd is both input and output while input as index.
+        /// </summary>
+        public static Vector256<short> VectorShuffleEach128(Vector256<short> vector0, Vector256<short> vector1, Vector256<short> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint16x16_t xvshuf_h(uint16x16_t vecj, uint16x16_t veck, uint16x16_t idx)
+        ///   LASX: XVSHUF.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorShuffleEach128(Vector256<ushort> vector0, Vector256<ushort> vector1, Vector256<ushort> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int32x8_t xvpermi_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector, const byte indexs) => VectorShuffleEach128(vector, indexs);
+
+        /// <summary>
+        ///  uint32x8_t xvpermi_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVPERMI.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector, const byte indexs) => VectorShuffleEach128Each128(vector, indexs);
+
+        /// <summary>
+        ///  int32x8_t xvshuf_w(int32x8_t vec0, int32x8_t vec1, int32x8_t idx)
+        ///   LASX: XVSHUF.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorShuffleEach128(Vector256<int> vector0, Vector256<int> vector1, Vector256<int> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint32x8_t xvshuf_w(uint32x8_t vecj, uint32x8_t veck, uint32x8_t idx)
+        ///   LASX: XVSHUF.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorShuffleEach128(Vector256<uint> vector0, Vector256<uint> vector1, Vector256<uint> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int64x4_t xvshuf_d(int64x4_t vec0, int64x4_t vec1, int64x4_t idx)
+        ///   LASX: XVSHUF.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorShuffleEach128(Vector256<long> vector0, Vector256<long> vector1, Vector256<long> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint64x4_t xvshuf_d(uint64x4_t vecj, uint64x4_t veck, uint64x4_t idx)
+        ///   LASX: XVSHUF.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorShuffleEach128(Vector256<ulong> vector0, Vector256<ulong> vector1, Vector256<ulong> indexs) => VectorShuffleEach128(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int8x32_t xvshuf4i_b(int8x32_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector256<sbyte> VectorShuffleBy4Elements(Vector256<sbyte> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  uint8x32_t xvshuf4i_b(uint8x32_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector256<byte> VectorShuffleBy4Elements(Vector256<byte> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  int16x16_t xvshuf4i_h(int16x16_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector256<short> VectorShuffleBy4Elements(Vector256<short> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  uint16x16_t xvshuf4i_h(uint16x16_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector256<ushort> VectorShuffleBy4Elements(Vector256<ushort> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  int32x8_t xvshuf4i_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<int> VectorShuffleBy4Elements(Vector256<int> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  uint32x8_t xvshuf4i_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVSHUF4I.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector256<uint> VectorShuffleBy4Elements(Vector256<uint> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  int64x4_t xvshuf4i_d(int64x4_t vec0, uint64x4_t vec1, uint8_t idx)
+        ///   LASX: XVSHUF4I.D Xd.4D, Xj.4D, ui4
+        /// </summary>
+        public static Vector256<long> VectorShuffleBy4Elements(Vector256<long> vector0, Vector256<long> vector1, byte indexs) => VectorShuffleBy4Elements(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint64x4_t xvshuf4i_d(uint64x4_t vec0, uint64x4_t vec1, uint8_t idx)
+        ///   LASX: XVSHUF4I.D Xd.4D, Xj.4D, ui4
+        /// </summary>
+        public static Vector256<ulong> VectorShuffleBy4Elements(Vector256<ulong> vector0, Vector256<ulong> vector1, byte indexs) => VectorShuffleBy4Elements(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int8x32_t xvilvl_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVILVL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionLowerEach128(Vector256<sbyte> left, Vector256<sbyte> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvilvl_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVILVL.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionLowerEach128(Vector256<byte> left, Vector256<byte> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  int16x16_t xvilvl_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVILVL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionLowerEach128(Vector256<short> left, Vector256<short> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  uint16x16_t xvilvl_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVILVL.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionLowerEach128(Vector256<ushort> left, Vector256<ushort> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  int32x8_t xvilvl_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVILVL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionLowerEach128(Vector256<int> left, Vector256<int> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  uint32x8_t xvilvl_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVILVL.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionLowerEach128(Vector256<uint> left, Vector256<uint> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  int64x4_t xvilvl_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVILVL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionLowerEach128(Vector256<long> left, Vector256<long> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  uint64x4_t xvilvl_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVILVL.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionLowerEach128(Vector256<ulong> left, Vector256<ulong> right) => VectorElementsFusionLowerEach128(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvilvh_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVILVH.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionHightEach128(Vector256<sbyte> left, Vector256<sbyte> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvilvh_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVILVH.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionHightEach128(Vector256<byte> left, Vector256<byte> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  int16x16_t xvilvh_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVILVH.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionHightEach128(Vector256<short> left, Vector256<short> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  uint16x16_t xvilvh_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVILVH.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionHightEach128(Vector256<ushort> left, Vector256<ushort> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  int32x8_t xvilvh_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVILVH.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionHightEach128(Vector256<int> left, Vector256<int> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  uint32x8_t xvilvh_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVILVH.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionHightEach128(Vector256<uint> left, Vector256<uint> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  int64x4_t xvilvh_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVILVH.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionHightEach128(Vector256<long> left, Vector256<long> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  uint64x4_t xvilvh_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVILVH.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionHightEach128(Vector256<ulong> left, Vector256<ulong> right) => VectorElementsFusionHightEach128(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvpackev_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPACKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionEven(Vector256<sbyte> left, Vector256<sbyte> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvpackev_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPACKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionEven(Vector256<byte> left, Vector256<byte> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int16x16_t xvpackev_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPACKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionEven(Vector256<short> left, Vector256<short> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint16x16_t xvpackev_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPACKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionEven(Vector256<ushort> left, Vector256<ushort> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int32x8_t xvpackev_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPACKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionEven(Vector256<int> left, Vector256<int> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint32x8_t xvpackev_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPACKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionEven(Vector256<uint> left, Vector256<uint> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int64x4_t xvpackev_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPACKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionEven(Vector256<long> left, Vector256<long> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint64x4_t xvpackev_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPACKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionEven(Vector256<ulong> left, Vector256<ulong> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvpackod_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPACKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementsFusionOdd(Vector256<sbyte> left, Vector256<sbyte> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvpackod_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPACKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementsFusionOdd(Vector256<byte> left, Vector256<byte> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int16x16_t xvpackod_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPACKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementsFusionOdd(Vector256<short> left, Vector256<short> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint16x16_t xvpackod_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPACKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementsFusionOdd(Vector256<ushort> left, Vector256<ushort> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int32x8_t xvpackod_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPACKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementsFusionOdd(Vector256<int> left, Vector256<int> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint32x8_t xvpackod_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPACKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementsFusionOdd(Vector256<uint> left, Vector256<uint> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int64x4_t xvpackod_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPACKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementsFusionOdd(Vector256<long> left, Vector256<long> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint64x4_t xvpackod_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPACKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementsFusionOdd(Vector256<ulong> left, Vector256<ulong> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvpickev_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPICKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorEvenElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvpickev_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPICKEV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorEvenElementsJoinEach128(Vector256<byte> left, Vector256<byte> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int16x16_t xvpickev_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPICKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorEvenElementsJoinEach128(Vector256<short> left, Vector256<short> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint16x16_t xvpickev_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPICKEV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorEvenElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int32x8_t xvpickev_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPICKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorEvenElementsJoinEach128(Vector256<int> left, Vector256<int> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint32x8_t xvpickev_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPICKEV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorEvenElementsJoinEach128(Vector256<uint> left, Vector256<uint> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int64x4_t xvpickev_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPICKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorEvenElementsJoinEach128(Vector256<long> left, Vector256<long> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint64x4_t xvpickev_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPICKEV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorEvenElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right) => VectorEvenElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int8x32_t xvpickod_b(int8x32_t vec0, int8x32_t vec1)
+        ///   LASX: XVPICKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorOddElementsJoinEach128(Vector256<sbyte> left, Vector256<sbyte> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvpickod_b(uint8x32_t vec0, uint8x32_t vec1)
+        ///   LASX: XVPICKOD.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorOddElementsJoinEach128(Vector256<byte> left, Vector256<byte> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int16x16_t xvpickod_h(int16x16_t vec0, int16x16_t vec1)
+        ///   LASX: XVPICKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorOddElementsJoinEach128(Vector256<short> left, Vector256<short> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint16x16_t xvpickod_h(uint16x16_t vec0, uint16x16_t vec1)
+        ///   LASX: XVPICKOD.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorOddElementsJoinEach128(Vector256<ushort> left, Vector256<ushort> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int32x8_t xvpickod_w(int32x8_t vec0, int32x8_t vec1)
+        ///   LASX: XVPICKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorOddElementsJoinEach128(Vector256<int> left, Vector256<int> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint32x8_t xvpickod_w(uint32x8_t vec0, uint32x8_t vec1)
+        ///   LASX: XVPICKOD.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorOddElementsJoinEach128(Vector256<uint> left, Vector256<uint> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  int64x4_t xvpickod_d(int64x4_t vec0, int64x4_t vec1)
+        ///   LASX: XVPICKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorOddElementsJoinEach128(Vector256<long> left, Vector256<long> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint64x4_t xvpickod_d(uint64x4_t vec0, uint64x4_t vec1)
+        ///   LASX: XVPICKOD.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorOddElementsJoinEach128(Vector256<ulong> left, Vector256<ulong> right) => VectorOddElementsJoinEach128(left, right);
+
+        /// <summary>
+        ///  uint8x32_t xvrepl128vei(uint8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<byte> VectorElementReplicateEach128(Vector256<byte> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  int8x32_t xvrepl128vei(int8x32_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> VectorElementReplicateEach128(Vector256<sbyte> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  int16x16_t xvrepl128vei(int16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<short> VectorElementReplicateEach128(Vector256<short> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint16x16_t xvrepl128vei(uint16x16_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEI_H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<ushort> VectorElementReplicateEach128(Vector256<ushort> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  int32x8_t xvrepl128vei(int32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
+        /// </summary>
+        public static Vector256<int> VectorElementReplicateEach128(Vector256<int> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint32x8_t xvrepl128vei(uint32x8_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_W Xd.8W, Xj.8W, ui2
+        /// </summary>
+        public static Vector256<uint> VectorElementReplicateEach128(Vector256<uint> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  int64x4_t xvrepl128vei(int64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
+        /// </summary>
+        public static Vector256<long> VectorElementReplicateEach128(Vector256<long> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint64x4_t xvrepl128vei(uint64x4_t vector, uint8_t idx)
+        ///   LASX: XVREPL128VEII_D Xd.4D, Xj.4D, ui1
+        /// </summary>
+        public static Vector256<ulong> VectorElementReplicateEach128(Vector256<ulong> vector, const byte elementIndexe) => VectorElementReplicateEach128(vector, elementIndexe);
+
+        /// <summary>
+        ///  int8x32_t xvextrins_b(int8x32_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector258<sbyte> UpdateOneVectorElementEach128(Vector258<sbyte> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  uint8x32_t xvextrins_b(uint8x32_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.B Xd.32B, Xj.32B, ui8
+        /// </summary>
+        public static Vector258<byte> UpdateOneVectorElementEach128(Vector258<byte> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  int16x16_t xvextrins_h(int16x16_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector258<short> UpdateOneVectorElementEach128(Vector258<short> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  uint16x16_t xvextrins_h(uint16x16_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.H Xd.16H, Xj.16H, ui8
+        /// </summary>
+        public static Vector258<ushort> UpdateOneVectorElementEach128(Vector258<ushort> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  int32x8_t xvextrins_w(int32x8_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector258<int> UpdateOneVectorElementEach128(Vector258<int> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  uint32x8_t xvextrins_w(uint32x8_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.W Xd.8W, Xj.8W, ui8
+        /// </summary>
+        public static Vector258<uint> UpdateOneVectorElementEach128(Vector258<uint> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  int64x4_t xvextrins_d(int64x4_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector258<long> UpdateOneVectorElementEach128(Vector258<long> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  uint64x4_t xvextrins_d(uint64x4_t vec, uint8_t idx)
+        ///   LASX: XVEXTRINS.D Xd.4D, Xj.4D, ui8
+        /// </summary>
+        public static Vector258<ulong> UpdateOneVectorElementEach128(Vector258<ulong> vector, const byte indexs) => UpdateOneVectorElementEach128(vector, indexs);
+
+        /// <summary>
+        ///  int8x32_t xvsigncov_b(int8x32_t sign, int8x32_t data)
+        ///   LASX: XVSIGNCOV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector258<sbyte> VectorElementNegatedBySign(Vector258<sbyte> sign, Vector258<sbyte> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        ///  int16x16_t xvsigncov_h(int16x16_t sign, int16x16_t data)
+        ///   LASX: XVSIGNCOV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector258<short> VectorElementNegatedBySign(Vector258<short> sign, Vector258<short> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        ///  int32x8_t xvsigncov_w(int32x8_t sign, int32x8_t data)
+        ///   LASX: XVSIGNCOV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector258<int> VectorElementNegatedBySign(Vector258<int> sign, Vector258<int> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        ///  int64x4_t xvsigncov_d(int64x4_t sign, int64x4_t data)
+        ///   LASX: XVSIGNCOV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector258<long> VectorElementNegatedBySign(Vector258<long> sign, Vector258<long> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        /// int8x32_t xvbitclri_b(int8x32_t a, const int n)
+        ///   LASX: XVBITCLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint8x32_t xvbitclri_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITCLRI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int16x16_t xvbitclri_h(int16x16_t a, const int n)
+        ///   LASX: XVBITCLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorElementBitClear(Vector256<short> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint16x16_t xvbitclri_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITCLRI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<int> VectorElementBitClear(Vector256<int> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitclri_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITCLRI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int64x4_t xvbitclri_d(int64x4_t a, const int n)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorElementBitClear(Vector256<long> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint64x4_t xvbitclri_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITCLRI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int8x32_t xvbitclr_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITCLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitClear(Vector256<sbyte> value, Vector256<sbyte> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint8x32_t xvbitclr_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITCLR.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementBitClear(Vector256<byte> value, Vector256<byte> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int16x16_t xvbitclr_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITCLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementBitClear(Vector256<short> value, Vector256<short> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint16x16_t xvbitclr_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITCLR.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitClear(Vector256<ushort> value, Vector256<ushort> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int32x8_t xvbitclr_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITCLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementBitClear(Vector256<int> value, Vector256<int> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitclr_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITCLR.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementBitClear(Vector256<uint> value, Vector256<uint> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int64x4_t xvbitclr_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITCLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementBitClear(Vector256<long> value, Vector256<long> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint64x4_t xvbitclr_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITCLR.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitClear(Vector256<ulong> value, Vector256<ulong> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int8x32_t xvbitseti_b(int8x32_t a, const int n)
+        ///   LASX: XVBITSETI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint8x32_t xvbitseti_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITSETI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int16x16_t xvbitseti_h(int16x16_t a, const int n)
+        ///   LASX: XVBITSETI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorElementBitSet(Vector256<short> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint16x16_t xvbitseti_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITSETI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<int> VectorElementBitSet(Vector256<int> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitseti_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITSETI.W Xd.4W, Xj.4W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int64x4_t xvbitseti_d(int64x4_t a, const int n)
+        ///   LASX: XVBITSETI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorElementBitSet(Vector256<long> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint64x4_t xvbitseti_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITSETI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int8x32_t xvbitset_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITSET.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitSet(Vector256<sbyte> value, Vector256<sbyte> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint8x32_t xvbitset_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITSET.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementBitSet(Vector256<byte> value, Vector256<byte> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int16x16_t xvbitset_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITSET.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementBitSet(Vector256<short> value, Vector256<short> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint16x16_t xvbitset_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITSET.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitSet(Vector256<ushort> value, Vector256<ushort> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int32x8_t xvbitset_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITSET.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementBitSet(Vector256<int> value, Vector256<int> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitset_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITSET.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementBitSet(Vector256<uint> value, Vector256<uint> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int64x4_t xvbitset_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITSET.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementBitSet(Vector256<long> value, Vector256<long> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint64x4_t xvbitset_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITSET.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitSet(Vector256<ulong> value, Vector256<ulong> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int8x32_t xvbitrevi_b(int8x32_t a, const int n)
+        ///   LASX: XVBITREVI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint8x32_t xvbitrevi_b(uint8x32_t a, const int n)
+        ///   LASX: XVBITREVI.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int16x16_t xvbitrevi_h(int16x16_t a, const int n)
+        ///   LASX: XVBITREVI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint16x16_t xvbitrevi_h(uint16x16_t a, const int n)
+        ///   LASX: XVBITREVI.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitrevi_w(uint32x8_t a, const int n)
+        ///   LASX: XVBITREVI.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int64x4_t xvbitrevi_d(int64x4_t a, const int n)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint64x4_t xvbitrevi_d(uint64x4_t a, const int n)
+        ///   LASX: XVBITREVI.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int8x32_t xvbitrev_b(int8x32_t a, int8x32_t b)
+        ///   LASX: XVBITREV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> VectorElementBitRevert(Vector256<sbyte> value, Vector256<sbyte> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint8x32_t xvbitrev_b(uint8x32_t a, uint8x32_t b)
+        ///   LASX: XVBITREV.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<byte> VectorElementBitRevert(Vector256<byte> value, Vector256<byte> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int16x16_t xvbitrev_h(int16x16_t value, int16x16_t index)
+        ///   LASX: XVBITREV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> VectorElementBitRevert(Vector256<short> value, Vector256<short> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint16x16_t xvbitrev_h(uint16x16_t value, uint16x16_t index)
+        ///   LASX: XVBITREV.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<ushort> VectorElementBitRevert(Vector256<ushort> value, Vector256<ushort> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int32x8_t xvbitrev_w(int32x8_t value, int32x8_t index)
+        ///   LASX: XVBITREV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<int> VectorElementBitRevert(Vector256<int> value, Vector256<int> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint32x8_t xvbitrev_w(uint32x8_t value, uint32x8_t index)
+        ///   LASX: XVBITREV.W Xd.8W, Xj.8W, Xk.8W
+        /// </summary>
+        public static Vector256<uint> VectorElementBitRevert(Vector256<uint> value, Vector256<uint> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int64x4_t xvbitrev_d(int64x4_t value, int64x4_t index)
+        ///   LASX: XVBITREV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<long> VectorElementBitRevert(Vector256<long> value, Vector256<long> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint64x4_t xvbitrev_d(uint64x4_t value, uint64x4_t index)
+        ///   LASX: XVBITREV.D Xd.4D, Xj.4D, Xk.4D
+        /// </summary>
+        public static Vector256<ulong> VectorElementBitRevert(Vector256<ulong> value, Vector256<ulong> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int8x32_t xvfrstp_b(int8x32_t value, int8x32_t save)
+        ///   LASX: XVFRSTP.B Xd.32B, Xj.32B, Xk.32B
+        /// </summary>
+        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, Vector256<sbyte> save) => IndexOfFirstNegativeElementEach128(value, save);
+
+        /// <summary>
+        /// int16x16_t xvfrstp_h(int16x16_t value, int16x16_t save)
+        ///   LASX: XVFRSTP.H Xd.16H, Xj.16H, Xk.16H
+        /// </summary>
+        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, Vector256<short> save) => IndexOfFirstNegativeElementEach128(value, save);
+
+        /// <summary>
+        /// int8x32_t xvfrstpi_b(int8x32_t value, uint8_t save)
+        ///   LASX: XVFRSTPI.B Xd.32B, Xj.32B, ui4
+        /// </summary>
+        public static Vector256<sbyte> IndexOfFirstNegativeElementEach128(Vector256<sbyte> value, const byte save) => IndexOfFirstNegativeElementEach128(value, save);
+
+        /// <summary>
+        /// int16x16_t xvfrstpi_h(int16x16_t value, uint8_t save)
+        ///   LASX: XVFRSTPI.H Xd.16H, Xj.16H, ui3
+        /// </summary>
+        public static Vector256<short> IndexOfFirstNegativeElementEach128(Vector256<short> value, const byte save) => IndexOfFirstNegativeElementEach128(value, save);
+
+        /// <summary>
+        /// int8x32_t xvsat_b(int8x32_t value, uint8_t ui3)
+        ///   LASX: XVSAT.B Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<sbyte> VectorSaturate(Vector256<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// int16x16_t xvsat_h(int16x16_t value, uint8_t ui4)
+        ///   LASX: XVSAT.H Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<short> VectorSaturate(Vector256<short> value, [ConstantExpected(Max = (byte)(15))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// int32x8_t xvsat_w(int32x8_t value, uint8_t ui5)
+        ///   LASX: XVSAT.W Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<int> VectorSaturate(Vector256<int> value, [ConstantExpected(Max = (byte)(31))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// int64x4_t xvsat_d(int64x4_t value, uint8_t ui6)
+        ///   LASX: XVSAT.D Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<long> VectorSaturate(Vector256<long> value, [ConstantExpected(Max = (byte)(63))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// uint8x32_t xvsat_bu(uint8x32_t value, uint8_t ui3)
+        ///   LASX: XVSAT.BU Xd.32B, Xj.32B, ui3
+        /// </summary>
+        public static Vector256<byte> VectorSaturateUnsigned(Vector256<byte> value, [ConstantExpected(Max = (byte)(7))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// uint16x16_t xvsat_hu(uint16x16_t value, uint8_t ui4)
+        ///   LASX: XVSAT.HU Xd.16H, Xj.16H, ui4
+        /// </summary>
+        public static Vector256<ushort> VectorSaturateUnsigned(Vector256<ushort> value, [ConstantExpected(Max = (byte)(15))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// uint32x8_t xvsat_wu(uint32x8_t value, uint8_t ui5)
+        ///   LASX: XVSAT.WU Xd.8W, Xj.8W, ui5
+        /// </summary>
+        public static Vector256<uint> VectorSaturateUnsigned(Vector256<uint> value, [ConstantExpected(Max = (byte)(31))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// uint64x4_t xvsat_du(uint64x4_t value, uint8_t ui6)
+        ///   LASX: XVSAT.DU Xd.4D, Xj.4D, ui6
+        /// </summary>
+        public static Vector256<ulong> VectorSaturateUnsigned(Vector256<ulong> value, [ConstantExpected(Max = (byte)(63))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// int32x8_t vfclass_s(float32x8_t a)
+        ///   LASX: XVFCLASS.S Vd.8S, Vj.8S
+        /// </summary>
+        public static Vector256<int> FloatClass(Vector256<float> value) => FloatClass(value);
+
+        /// <summary>
+        /// int64x4_t vfclass_d(float64x4_t a)
+        ///   LASX: XVFCLASS.D Vd.4D, Vj.4D
+        /// </summary>
+        public static Vector256<long> FloatClass(Vector256<double> value) => FloatClass(value);
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.PlatformNotSupported.cs
new file mode 100644
index 00000000000000..4e3609ac5f3194
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.PlatformNotSupported.cs
@@ -0,0 +1,302 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable IDE0060 // unused parameters
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    /// <summary>
+    /// This class provides access to the LA64 base hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+    abstract class LoongArchBase
+    {
+        internal LoongArchBase() { }
+
+        public static bool IsSupported { [Intrinsic] get => false; }
+
+        [Intrinsic]
+        public abstract class LoongArch64
+        {
+            internal LoongArch64() { }
+
+            public static bool IsSupported { [Intrinsic] get => false; }
+
+            /// <summary>
+            ///   LA64: CLO.W rd, rj
+            /// </summary>
+            public static int LeadingSignCount(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLO.W rd, rj
+            /// </summary>
+            public static int LeadingSignCount(uint value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLO.D rd, rj
+            /// </summary>
+            public static int LeadingSignCount(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLO.D rd, rj
+            /// </summary>
+            public static int LeadingSignCount(ulong value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLZ.W rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLZ.W rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLZ.D rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CLZ.D rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTO.W rd, rj
+            /// </summary>
+            public static int TrailingOneCount(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTO.W rd, rj
+            /// </summary>
+            public static int TrailingOneCount(uint value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTO.D rd, rj
+            /// </summary>
+            public static int TrailingOneCount(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTO.D rd, rj
+            /// </summary>
+            public static int TrailingOneCount(ulong value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTZ.W rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTZ.W rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(uint value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTZ.D rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CTZ.D rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(ulong value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: MULH.D rd, rj, rk
+            /// </summary>
+            public static long MultiplyHigh(long left, long right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: MULH.DU rd, rj, rk
+            /// </summary>
+            public static ulong MultiplyHigh(ulong left, ulong right) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: BITREV.D rd, rj
+            /// </summary>
+            public static long ReverseElementBits(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: BITREV.D rd, rj
+            /// </summary>
+            public static ulong ReverseElementBits(ulong value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: BITREV.W rd, rj
+            /// </summary>
+            public static long ReverseElementBits(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: BITREV.W rd, rj
+            /// </summary>
+            public static ulong ReverseElementBits(uint value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: REVB.2W rd, rj
+            /// </summary>
+            public static int ReverseElementBits(int value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: REVB.2W rd, rj
+            /// </summary>
+            public static uint ReverseElementBits(uint value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: REVB.D rd, rj
+            /// </summary>
+            public static long ReverseElementBits(long value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: REVB.D rd, rj
+            /// </summary>
+            public static ulong ReverseElementBits(ulong value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: FRECIPE.S fd, fj
+            /// </summary>
+            public static float ReciprocalEstimate(float value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: FRECIPE.D fd, fj
+            /// </summary>
+            public static double ReciprocalEstimate(double value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: FRSQRTE.S fd, fj
+            /// </summary>
+            public static float ReciprocalSqrtEstimate(float value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: FRSQRTE.D fd, fj
+            /// </summary>
+            public static double ReciprocalSqrtEstimate(double value) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRC.W.B.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, byte checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRC.W.H.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, ushort checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRC.W.W.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, uint checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRC.W.D.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, ulong checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRCC.W.B.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, byte checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRCC.W.H.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, ushort checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRCC.W.W.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, uint checks) { throw new PlatformNotSupportedException(); }
+
+            /// <summary>
+            ///   LA64: CRCC.W.D.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, ulong checks) { throw new PlatformNotSupportedException(); }
+        }
+
+        /// <summary>
+        ///   LA32/LA64: MULH.W rd, rj, rk
+        /// </summary>
+        public static long MultiplyHigh(int left, int right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: MULH.WU rd, rj, rk
+        /// </summary>
+        public static ulong MultiplyHigh(uint left, uint right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FSQRT.S fd, fj
+        /// </summary>
+        public static float SquareRoot(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FSQRT.D fd, fj
+        /// </summary>
+        public static double SquareRoot(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FRECIP.S fd, fj
+        /// </summary>
+        public static float Reciprocal(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FRECIP.D fd, fj
+        /// </summary>
+        public static double Reciprocal(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FRSQRT.S fd, fj
+        /// </summary>
+        public static float ReciprocalSqrt(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FRSQRT.D fd, fj
+        /// </summary>
+        public static double ReciprocalSqrt(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FLOGB.S fd, fj
+        /// </summary>
+        public static float FloatLogarithm2(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FLOGB.D fd, fj
+        /// </summary>
+        public static double FloatLogarithm2(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FSCALEB.S fd, fj, fk
+        /// </summary>
+        public static float FloatScaleBinary(float value, int index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FSCALEB.D fd, fj, fk
+        /// </summary>
+        public static double FloatScaleBinary(double value, long index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FCOPYSIGN.S fd, fj, fk
+        /// </summary>
+        public static float FloatCopySign(float value, float sign) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FCOPYSIGN.D fd, fj, fk
+        /// </summary>
+        public static double FloatCopySign(double value, double sign) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FCLASS.S fd, fj
+        /// </summary>
+        public static float FloatClass(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   LA32/LA64: FCLASS.S fd, fj
+        /// </summary>
+        public static double FloatClass(double value) { throw new PlatformNotSupportedException(); }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.cs
new file mode 100644
index 00000000000000..4e24b6f743623b
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/LoongArchBase.cs
@@ -0,0 +1,297 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    /// <summary>
+    /// This class provides access to the LoongArch base hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class LoongArchBase
+    {
+        internal LoongArchBase() { }
+
+        public static bool IsSupported { get => IsSupported; }
+
+        [Intrinsic]
+        public abstract class LoongArch64
+        {
+            internal LoongArch64() { }
+
+            public static bool IsSupported { get => IsSupported; }
+
+            /// <summary>
+            ///   LA64: CLO.W rd, rj
+            /// </summary>
+            public static int LeadingSignCount(int value) => LeadingSignCount(value);
+
+            /// <summary>
+            ///   LA64: CLO.W rd, rj
+            /// </summary>
+            public static int LeadingSignCount(uint value) => LeadingSignCount(value);
+
+            /// <summary>
+            ///   LA64: CLO.D rd, rj
+            /// </summary>
+            public static int LeadingSignCount(long value) => LeadingSignCount(value);
+
+            /// <summary>
+            ///   LA64: CLO.D rd, rj
+            /// </summary>
+            public static int LeadingSignCount(ulong value) => LeadingSignCount(value);
+
+            /// <summary>
+            ///   LA64: CLZ.W rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(int value) => LeadingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CLZ.W rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(uint value) => LeadingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CLZ.D rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(long value) => LeadingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CLZ.D rd, rj
+            /// </summary>
+            public static int LeadingZeroCount(ulong value) => LeadingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CTO.W rd, rj
+            /// </summary>
+            public static int TrailingOneCount(int value) => TrailingOneCount(value);
+
+            /// <summary>
+            ///   LA64: CTO.W rd, rj
+            /// </summary>
+            public static int TrailingOneCount(uint value) => TrailingOneCount(value);
+
+            /// <summary>
+            ///   LA64: CTO.D rd, rj
+            /// </summary>
+            public static int TrailingOneCount(long value) => TrailingOneCount(value);
+
+            /// <summary>
+            ///   LA64: CTO.D rd, rj
+            /// </summary>
+            public static int TrailingOneCount(ulong value) => TrailingOneCount(value);
+
+            /// <summary>
+            ///   LA64: CTZ.W rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(int value) => TrailingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CTZ.W rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(uint value) => TrailingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CTZ.D rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(long value) => TrailingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: CTZ.D rd, rj
+            /// </summary>
+            public static int TrailingZeroCount(ulong value) => TrailingZeroCount(value);
+
+            /// <summary>
+            ///   LA64: MULH.D rd, rj, rk
+            /// </summary>
+            public static long MultiplyHigh(long left, long right) => MultiplyHigh(left, right);
+
+            /// <summary>
+            ///   LA64: MULH.DU rd, rj, rk
+            /// </summary>
+            public static ulong MultiplyHigh(ulong left, ulong right) => MultiplyHigh(left, right);
+
+            /// <summary>
+            ///   LA64: BITREV.D rd, rj
+            /// </summary>
+            public static long ReverseElementBits(long value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: BITREV.D rd, rj
+            /// </summary>
+            public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: BITREV.W rd, rj
+            /// </summary>
+            public static long ReverseElementBits(int value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: BITREV.W rd, rj
+            /// </summary>
+            public static ulong ReverseElementBits(uint value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: REVB.2W rd, rj
+            /// </summary>
+            public static int ReverseElementBits(int value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: REVB.2W rd, rj
+            /// </summary>
+            public static uint ReverseElementBits(uint value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: REVB.D rd, rj
+            /// </summary>
+            public static long ReverseElementBits(long value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: REVB.D rd, rj
+            /// </summary>
+            public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value);
+
+            /// <summary>
+            ///   LA64: FRECIPE.S fd, fj
+            /// </summary>
+            public static float ReciprocalEstimate(float value) => ReciprocalEstimate(value);
+
+            /// <summary>
+            ///   LA64: FRECIPE.D fd, fj
+            /// </summary>
+            public static double ReciprocalEstimate(double value) => ReciprocalEstimate(value);
+
+            /// <summary>
+            ///   LA64: FRSQRTE.S fd, fj
+            /// </summary>
+            public static float ReciprocalSqrtEstimate(float value) => ReciprocalSqrtEstimate(value);
+
+            /// <summary>
+            ///   LA64: FRSQRTE.D fd, fj
+            /// </summary>
+            public static double ReciprocalSqrtEstimate(double value) => ReciprocalSqrtEstimate(value);
+
+            /// <summary>
+            ///   LA64: CRC.W.B.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, byte checks) => CyclicRedundancyCheckIEEE8023(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRC.W.H.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, ushort checks) => CyclicRedundancyCheckIEEE8023(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRC.W.W.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, uint checks) => CyclicRedundancyCheckIEEE8023(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRC.W.D.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckIEEE8023(int crc, ulong checks) => CyclicRedundancyCheckIEEE8023(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRCC.W.B.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, byte checks) => CyclicRedundancyCheckCastagnoli(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRCC.W.H.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, ushort checks) => CyclicRedundancyCheckCastagnoli(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRCC.W.W.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, uint checks) => CyclicRedundancyCheckCastagnoli(crc, checks);
+
+            /// <summary>
+            ///   LA64: CRCC.W.D.W rd, rj, rk
+            /// </summary>
+            public static long CyclicRedundancyCheckCastagnoli(int crc, ulong checks) => CyclicRedundancyCheckCastagnoli(crc, checks);
+        }
+
+        /// <summary>
+        ///   LA32/LA64: MULH.W rd, rj, rk
+        /// </summary>
+        public static long MultiplyHigh(int left, int right) => MultiplyHigh(left, right);
+
+        /// <summary>
+        ///   LA32/LA64: MULH.WU rd, rj, rk
+        /// </summary>
+        public static ulong MultiplyHigh(uint left, uint right) => MultiplyHigh(left, right);
+
+        /// <summary>
+        ///   LA32/LA64: FSQRT.S fd, fj
+        /// </summary>
+        public static float SquareRoot(float value) => SquareRoot(value);
+
+        /// <summary>
+        ///   LA32/LA64: FSQRT.D fd, fj
+        /// </summary>
+        public static double SquareRoot(double value) => SquareRoot(value);
+
+        /// <summary>
+        ///   LA32/LA64: FRECIP.S fd, fj
+        /// </summary>
+        public static float Reciprocal(float value) => Reciprocal(value);
+
+        /// <summary>
+        ///   LA32/LA64: FRECIP.D fd, fj
+        /// </summary>
+        public static double Reciprocal(double value) => Reciprocal(value);
+
+        /// <summary>
+        ///   LA32/LA64: FRSQRT.S fd, fj
+        /// </summary>
+        public static float ReciprocalSqrt(float value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        ///   LA32/LA64: FRSQRT.D fd, fj
+        /// </summary>
+        public static double ReciprocalSqrt(double value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        ///   LA32/LA64: FLOGB.S fd, fj
+        /// </summary>
+        public static float FloatLogarithm2(float value) => FloatLogarithm2(value);
+
+        /// <summary>
+        ///   LA32/LA64: FLOGB.D fd, fj
+        /// </summary>
+        public static double FloatLogarithm2(double value) => FloatLogarithm2(value);
+
+        /// <summary>
+        ///   LA32/LA64: FSCALEB.S fd, fj, fk
+        /// </summary>
+        public static float FloatScaleBinary(float value, int index) => FloatScaleBinary(value, index);
+
+        /// <summary>
+        ///   LA32/LA64: FSCALEB.D fd, fj, fk
+        /// </summary>
+        public static double FloatScaleBinary(double value, long index) => FloatScaleBinary(value, index);
+
+        /// <summary>
+        ///   LA32/LA64: FCOPYSIGN.S fd, fj, fk
+        /// </summary>
+        public static float FloatCopySign(float value, float sign) => FloatCopySign(value, sign);
+
+        /// <summary>
+        ///   LA32/LA64: FCOPYSIGN.D fd, fj, fk
+        /// </summary>
+        public static double FloatCopySign(double value, double sign) => FloatCopySign(value, sign);
+
+        /// <summary>
+        ///   LA32/LA64: FCLASS.S fd, fj
+        /// </summary>
+        public static float FloatClass(float value) => FloatClass(value);
+
+        /// <summary>
+        ///   LA32/LA64: FCLASS.S fd, fj
+        /// </summary>
+        public static double FloatClass(double value) => FloatClass(value);
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.PlatformNotSupported.cs
new file mode 100644
index 00000000000000..d970df04c3c7cf
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.PlatformNotSupported.cs
@@ -0,0 +1,5943 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    /// <summary>
+    /// This class provides access to the LSX-128bits hardware instructions via intrinsics
+    /// </summary>
+    [CLSCompliant(false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+    abstract class Lsx : LoongArchBase
+    {
+        internal Lsx() { }
+
+        public static new bool IsSupported { [Intrinsic] get { return false; } }
+
+        /// <summary>
+        /// int8x8_t vadd_b(int8x8_t a, int8x8_t b)
+        ///   LSX: VADD.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vadd_b(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VADD.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vadd_h(int16x4_t a, int16x4_t b)
+        ///   LSX: VADD.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<short> Add(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vadd_h(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VADD.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vadd_w(int32x2_t a, int32x2_t b)
+        ///   LSX: VADD.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<int> Add(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vadd_w(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VADD.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vadd_d(int64x1_t a, int64x1_t b)
+        ///   LSX: VADD.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<long> Add(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vadd_d(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VADD.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<ulong> Add(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vfadd_s(float32x2_t a, float32x2_t b)
+        ///   LSX: VFADD.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector64<float> Add(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t vfadd_d(float64x1_t a, float64x1_t b)
+        ///   LSX: VFADD.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<double> Add(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vadd_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vadd_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vadd_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vadd_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfadd_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFADD.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfadd_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vsadd_b(int8x8_t a, uint8x8_t b)
+        ///   LSX: VSADD.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vsadd_bu(uint8x8_t a, int8x8_t b)
+        ///   LSX: VSADD.BU Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vsadd_h(int16x4_t a, uint16x4_t b)
+        ///   LSX: VSADD.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vsadd_hu(uint16x4_t a, int16x4_t b)
+        ///   LSX: VSADD.HU Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vsadd_w(int32x2_t a, uint32x2_t b)
+        ///   LSX: VSADD.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vsadd_wu(uint32x2_t a, int32x2_t b)
+        ///   LSX: VSADD.WU Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vsadd_d(int64x1_t a, uint64x1_t b)
+        ///   LSX: VSADD.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<long> AddSaturate(Vector64<long> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vsadd_du(uint64x1_t a, int64x1_t b)
+        ///   LSX: VSADD.DU Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<ulong> AddSaturate(Vector64<ulong> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsadd_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSADD.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsadd_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSADD.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsadd_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSADD.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsadd_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSADD.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vhaddw_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VHADDW.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vhaddw_hu_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VHADDW.HU.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AddOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vhaddw_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VHADDW.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vhaddw_wu_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VHADDW.WU.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> AddOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vhaddw_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VHADDW.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vhaddw_du_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VHADDW.DU.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vhaddw_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VHADDW.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vhaddw_qu_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VHADDW.QU.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vaddwev_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWEV.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vaddwev_h_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADDWEV.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vaddwev_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWEV.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddEvenElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vaddwev_w_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADDWEV.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> AddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vaddwev_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWEV.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vaddwev_d_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADDWEV.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vaddwev_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWEV.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vaddwev_q_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADDWEV.Q.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vaddwod_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddOddElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vaddwod_h_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADDWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AddOddElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vaddwod_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWOD.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddOddElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vaddwod_w_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADDWOD.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> AddOddElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vaddwod_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWOD.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vaddwod_d_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADDWOD.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vaddwod_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWOD.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vaddwod_q_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADDWOD.Q.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vaddwev_h_bu_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWEV.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddEvenElementsWidening(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vaddwev_w_hu_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWEV.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddEvenElementsWidening(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vaddwev_d_wu_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWEV.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vaddwev_q_du_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWEV.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vaddwod_h_bu_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWOD.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddOddElementsWidening(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vaddwod_w_hu_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWOD.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddOddElementsWidening(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vaddwod_d_wu_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWOD.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vaddwod_q_du_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWOD.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        //// TODO: LA-SIMD: add HorizontalSubtract for LA64.
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.HU.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.WU.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.DU.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.QU.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_float_elements witin vector.
+        /// </summary>
+        public static Vector64<float> AddHorizontalElements(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_double_elements witin vector.
+        /// </summary>
+        public static Vector64<double> AddHorizontalElements(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vsub_b(int8x8_t a, int8x8_t b)
+        ///   LSX: VSUB.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<sbyte> Subtract(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vsub_b(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VSUB.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<byte> Subtract(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vsub_h(int16x4_t a, int16x4_t b)
+        ///   LSX: VSUB.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<short> Subtract(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vsub_h(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VSUB.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<ushort> Subtract(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vsub_w(int32x2_t a, int32x2_t b)
+        ///   LSX: VSUB.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<int> Subtract(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vsub_w(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VSUB.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<uint> Subtract(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vsub_d(int64x1_t a, int64x1_t b)
+        ///   LSX: VSUB.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<long> Subtract(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vsub_d(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VSUB.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<ulong> Subtract(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vfsub_s(float32x2_t a, float32x2_t b)
+        ///   LSX: VFSUB.S Vd.2S, Vj.2S, Vk.2S
+        /// </summary>
+        public static Vector64<float> Subtract(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t vfsub_d(float64x1_t a, float64x1_t b)
+        ///   LSX: VFSUB.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<double> Subtract(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsub_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsub_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsub_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsub_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsub_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsub_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsub_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsub_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfsub_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfsub_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vhsubw_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VHSUBW.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> SubtractOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vhsubw_hu_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VHSUBW.HU.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> SubtractOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vhsubw_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VHSUBW.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> SubtractOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vhsubw_wu_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VHSUBW.WU.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> SubtractOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vhsubw_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VHSUBW.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> SubtractOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vhsubw_du_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VHSUBW.DU.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> SubtractOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vhsubw_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VHSUBW.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> SubtractOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vhsubw_qu_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VHSUBW.QU.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> SubtractOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vssub_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vssub_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSSUB.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssub_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssub_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSSUB.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vssub_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssub_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSSUB.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vssub_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> SubtractSaturate(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vssub_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSSUB.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> SubtractSaturate(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmul_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmul_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmul_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmul_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmul_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmul(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmul_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmul(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmul_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMUL.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmul_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmuh_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUH.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> MultiplyHight(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmuh_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUH.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> MultiplyHight(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmuh_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUH.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> MultiplyHight(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmuh_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUH.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> MultiplyHight(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmuh_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> MultiplyHight(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmuh_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUH.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> MultiplyHight(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmuh_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUH.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyHight(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmuh_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUH.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplyHight(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vdiv_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VDIV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Divide(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vdiv_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VDIV.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Divide(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vdiv_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VDIV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Divide(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vdiv_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VDIV.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Divide(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vdiv_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VDIV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vdiv_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VDIV.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vdiv_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Divide(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vdiv_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VDIV.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Divide(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfdiv_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFDIV.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfdiv_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmod_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Modulo(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmod_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMOD.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Modulo(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmod_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Modulo(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmod_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMOD.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Modulo(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmod_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Modulo(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmod_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMOD.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Modulo(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmod_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Modulo(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmod_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMOD.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Modulo(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmadd_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S, Va.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplyAdd(Vector128<float> left, Vector128<float> right, Vector128<float> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmadd_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplyAdd(Vector128<double> left, Vector128<double> right, Vector128<double> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfnmadd_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFNMADD.S Vd.4S, Vj.4S, Vk.4S, Va.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplyAddNegated(Vector128<float> left, Vector128<float> right, Vector128<float> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfnmadd_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFNMADD.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplyAddNegated(Vector128<double> left, Vector128<double> right, Vector128<double> addend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmadd_b(int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B               //NOTE: The Vd is both input and output while input as addend.
+        /// </summary>
+        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmadd_b(uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmadd_h(int16x8_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmadd_h(uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmadd_w(int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmadd_w(uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMADD.W  Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmadd_d(int64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyAdd(Vector128<long> minuend, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmadd_d(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplyAdd(Vector128<ulong> minuend, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmsub_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S, Va,4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplySubtract(Vector128<float> left, Vector128<float> right, Vector128<float> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmsub_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplySubtract(Vector128<double> left, Vector128<double> right, Vector128<double> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfnmsub_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFNMSUB.S Vd.4S, Vj.4S, Vk.4S, Va,4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplySubtractNegated(Vector128<float> left, Vector128<float> right, Vector128<float> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfnmsub_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFNMSUB.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplySubtractNegated(Vector128<double> left, Vector128<double> right, Vector128<double> minuend) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmsub_b(int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B               //NOTE: The Vd is both input and output while input as minuend.
+        /// </summary>
+        public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmsub_b(uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> MultiplySubtract(Vector128<byte> minuend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmsub_h(int16x8_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> MultiplySubtract(Vector128<short> minuend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmsub_h(uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> MultiplySubtract(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmsub_w(int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmsub_w(uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmsub_d(int64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplySubtract(Vector128<long> minuend, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmsub_d(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplySubtract(Vector128<ulong> minuend, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmaddwev_h_b(int16x8_t a, int8x8_t b, int8x8_t c)
+        ///   LSX: VMADDWEV.H.B Vd.8H, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningLowerAndAdd(Vector128<short> addend, Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmaddwev_h_bu(uint16x8_t a, uint8x8_t b, uint8x8_t c)
+        ///   LSX: VMADDWEV.H.BU Vd.8H, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningLowerAndAdd(Vector128<ushort> addend, Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmaddwev_w_h(int32x4_t a, int16x4_t b, int16x4_t c)
+        ///   LSX: VMADDWEV.W.H Vd.4W, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmaddwev_w_hu(uint32x4_t a, uint16x4_t b, uint16x4_t c)
+        ///   LSX: VMADDWEV.W.HU Vd.4W, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmaddwev_d_w(int64x2_t a, int32x2_t b, int32x2_t c)
+        ///   LSX: VMADDWEV.D.W Vd.2D, Vj.2S, Vk.2S
+        /// </summary>
+        public static Vector128<long> MultiplyWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmaddwev_d_wu(uint64x2_t a, uint32x2_t b, uint32x2_t c)
+        ///   LSX: VMADDWEV.D.WU Vd.2D, Vj.2S, Vk.2S
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmaddwod_h_b(int16x8_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADDWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningUpperAndAdd(Vector128<short> addend, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmaddwod_h_bu(uint16x8_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VMADDWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningUpperAndAdd(Vector128<ushort> addend, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmaddwod_w_h(int32x4_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMADDWOD.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmaddwod_w_hu(uint32x4_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMADDWOD.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmaddwod_d_w(int64x2_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADDWOD.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> MultiplyWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmaddwod_d_wu(uint64x2_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMADDWOD.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vmsknz_b(int8x16_t value)
+        ///   LSX: VMSKNZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareNotEqualZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vmsknz_b(uint8x16_t value)
+        ///   LSX: VMSKNZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> CompareNotEqualZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vseqi_b(int8x16_t a, int8_t si5)
+        ///   LSX: VSEQI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vseqi_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSEQI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> CompareEqual(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vseqi_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSEQI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vseqi_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSEQI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> CompareEqual(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vseq_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSEQ.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vseq_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSEQ.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vseq_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSEQ.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vseq_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSEQ.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vseq_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSEQ.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vseq_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSEQ.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vseq_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vseq_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vfcmp_ceq_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CEQ.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vfcmp_ceq_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vmskltz_b(int8x16_t value)
+        ///   LSX: VMSKLTZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThanZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vmskltz_h(int16x8_t value)
+        ///   LSX: VMSKLTZ.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> CompareLessThanZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vmskltz_w(int32x4_t value)
+        ///   LSX: VMSKLTZ.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> CompareLessThanZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vmskltz_d(int64x2_t value)
+        ///   LSX: VMSKLTZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThanZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vslti_b(int8x16_t a, int8_t si5)
+        ///   LSX: VSLTI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vslti_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSLTI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> CompareLessThan(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vslti_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSLTI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vslti_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSLTI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> CompareLessThan(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslt_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLT.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslt_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLT.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslt_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLT.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslt_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLT.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslt_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslt_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslt_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslt_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLT.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vfcmp_clt_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vfcmp_clt_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vslei_b(int8x16_t a, int8_t si5)
+        ///   LSX: VSLEI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vslei_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSLEI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vslei_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSLEI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vslei_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSLEI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsle_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsle_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsle_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsle_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslei_bu(uint8x16_t a, uint8_t ui5)
+        ///   LSX: VSLEI.BU Vd.16B, Vj.16B, ui5
+        /// </summary>
+        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslei_hu(uint16x8_t a, uint8_t ui5)
+        ///   LSX: VSLEI.HU Vd.8H, Vj.8H, ui5
+        /// </summary>
+        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslei_wu(uint32x4_t a, uint8_t ui5)
+        ///   LSX: VSLEI.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslei_du(uint64x2_t a, uint8_t ui5)
+        ///   LSX: VSLEI.DU Vd.2D, Vj.2D, ui5
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value, [ConstantExpected(Max = (byte)(31))] byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsle_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsle_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsle_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsle_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLE.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vfcmp_cle_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vfcmp_cle_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsle_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsle_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsle_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsle_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsle_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsle_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsle_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsle_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLE.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vfcmp_cle_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThan(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vfcmp_cle_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThan(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vmskgez_b(int8x16_t value)
+        ///   LSX: VMSKGEZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareGreaterThanOrEqualZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslt_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLT.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslt_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLT.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslt_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLT.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslt_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLT.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslt_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslt_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslt_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslt_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLT.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vfcmp_clt_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vfcmp_clt_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmaxi_b(int8x16_t a, int8_t si5)
+        ///   LSX: VMAXI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> Max(Vector128<sbyte> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmaxi_bu(uint8x16_t a, int8_t si5)
+        ///   LSX: VMAXI.BU Vd.16B, Vj.16B, ui5
+        /// </summary>
+        public static Vector128<byte> Max(Vector128<byte> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmaxi_h(int16x8_t a, int8_t si5)
+        ///   LSX: VMAXI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> Max(Vector128<short> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmaxi_hu(uint16x8_t a, int8_t si5)
+        ///   LSX: VMAXI.HU Vd.8H, Vj.8H, ui5
+        /// </summary>
+        public static Vector128<ushort> Max(Vector128<ushort> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmaxi_w(int32x4_t a, int8_t si5)
+        ///   LSX: VMAXI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> Max(Vector128<int> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmaxi_wu(uint32x4_t a, int8_t si5)
+        ///   LSX: VMAXI.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> Max(Vector128<uint> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmaxi_d(int64x2_t a, int8_t si5)
+        ///   LSX: VMAXI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> Max(Vector128<long> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmaxi_du(uint64x2_t a, int8_t si5)
+        ///   LSX: VMAXI.DU Vd.2D, Vj.2D, ui5
+        /// </summary>
+        public static Vector128<ulong> Max(Vector128<ulong> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmax_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMAX.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmax_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMAX.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmax_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMAX.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmax_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMAX.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmax_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMAX.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmax_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMAX.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmax_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMAX.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmax_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMAX.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmax_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMAX.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmax_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMAX.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmaxa_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMAXA.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> MaxFloatAbsolute(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmaxa_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMAXA.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> MaxFloatAbsolute(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmini_b(int8x16_t a, int8_t si5)
+        ///   LSX: VMINI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> Min(Vector128<sbyte> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmini_bu(uint8x16_t a, int8_t si5)
+        ///   LSX: VMINI.BU Vd.16B, Vj.16B, ui5
+        /// </summary>
+        public static Vector128<byte> Min(Vector128<byte> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmini_h(int16x8_t a, int8_t si5)
+        ///   LSX: VMINI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> Min(Vector128<short> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmini_hu(uint16x8_t a, int8_t si5)
+        ///   LSX: VMINI.HU Vd.8H, Vj.8H, ui5
+        /// </summary>
+        public static Vector128<ushort> Min(Vector128<ushort> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmini_w(int32x4_t a, int8_t si5)
+        ///   LSX: VMINI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> Min(Vector128<int> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmini_wu(uint32x4_t a, int8_t si5)
+        ///   LSX: VMINI.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> Min(Vector128<uint> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmini_d(int64x2_t a, int8_t si5)
+        ///   LSX: VMINI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> Min(Vector128<long> value, const sbyte si5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmini_du(uint64x2_t a, int8_t si5)
+        ///   LSX: VMINI.DU Vd.2D, Vj.2D, ui5
+        /// </summary>
+        public static Vector128<ulong> Min(Vector128<ulong> value, const byte ui5) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vmin_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMIN.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vmin_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMIN.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmin_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMIN.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmin_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMIN.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmin_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMIN.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmin_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMIN.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmin_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMIN.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmin_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMIN.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmin_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMIN.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmin_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMIN.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfmina_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMINA.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> MinFloatAbsolute(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfmina_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMINA.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> MinFloatAbsolute(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitsel_v(uint8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> BitwiseSelect(Vector128<sbyte> select, Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitsel_v(uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> BitwiseSelect(Vector128<byte> select, Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitsel_v(uint16x8_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> BitwiseSelect(Vector128<short> select, Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitsel_v(uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> BitwiseSelect(Vector128<ushort> select, Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vbitsel_v(uint32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> BitwiseSelect(Vector128<int> select, Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitsel_v(uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> BitwiseSelect(Vector128<uint> select, Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitsel_v(uint64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> BitwiseSelect(Vector128<long> select, Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitsel_v(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> BitwiseSelect(Vector128<ulong> select, Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vbitsel_v(uint32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> BitwiseSelect(Vector128<float> select, Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vbitsel_v(uint64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> BitwiseSelect(Vector128<double> select, Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vabsd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VABSD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AbsoluteDifference(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vabsd_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VABSD.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AbsoluteDifference(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vabsd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VABSD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AbsoluteDifference(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vabsd_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VABSD.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AbsoluteDifference(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vabsd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VABSD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vabsd_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VABSD.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vabsd_d(uint64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VABSD.D Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AbsoluteDifference(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vabsd_du(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VABSD.DU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AbsoluteDifference(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// float32x4_t TODO(float32x4_t a, float32x4_t b)   multi-instructions.
+        /////   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        ///// </summary>
+        //public static Vector128<float> AbsoluteDifference(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// float64x2_t TODO(float64x2_t a, float64x2_t b)
+        /////   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        ///// </summary>
+        //public static Vector128<double> AbsoluteDifference(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vld(int8_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vld(uint8_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vld(int16_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vld(uint16_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vld(int32_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vld(uint32_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vld(int64_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vld(uint64_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vld(float32_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vld(float64_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vldx(int8_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.16B, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vldx(uint8_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.16B, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vldx(int16_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.8H, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vldx(uint16_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.8H, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vldx(int32_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.4W, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vldx(uint32_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.4W, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vldx(int64_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.2D, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vldx(uint64_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.2D, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vldx(float32_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.4S, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vldx(float64_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.2D, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address, long offsetValue) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vldrepl_b(int8_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.B Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadElementReplicateVector(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vldrepl_b(uint8_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.B Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<byte> LoadElementReplicateVector(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vldrepl_h(int16_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.H Vd.8H, Rj, si11
+        /// </summary>
+        public static unsafe Vector128<short> LoadElementReplicateVector(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vldrepl_h(uint16_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.H Vd.8H, Rj, si11
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadElementReplicateVector(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vldrepl_w(int32_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.W Vd.4W, Rj, si10
+        /// </summary>
+        public static unsafe Vector128<int> LoadElementReplicateVector(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vldrepl_w(uint32_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.W Vd.4W, Rj, si10
+        /// </summary>
+        public static unsafe Vector128<uint> LoadElementReplicateVector(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vldrepl_d(int64_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.D Vd.2D, Rj, si9
+        /// </summary>
+        public static unsafe Vector128<long> LoadElementReplicateVector(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vldrepl_d(uint64_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.D Vd.2D, Rj, si9
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadElementReplicateVector(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vld(float32_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.W Vd.4S, Rj, si10
+        /// </summary>
+        public static unsafe Vector128<float> LoadElementReplicateVector(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vldrepl_d(float64_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.D Vd.2D, Rj, si9
+        /// </summary>
+        public static unsafe Vector128<double> LoadElementReplicateVector(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrecip_s(float32x4_t a)
+        ///   LSX: VFRECIP.S Vd.4S Vj.4S
+        /// </summary>
+        public static Vector128<float> Reciprocal(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrecip_d(float64x2_t a)
+        ///   LSX: VFRECIP.D Vd.2D Vj.2D
+        /// </summary>
+        public static Vector128<double> Reciprocal(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrsqrt_s(float32x4_t a)
+        ///   LSX: VFRSQRT.S Vd.4S Vj.4S
+        /// </summary>
+        public static Vector128<float> ReciprocalSqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrsqrt_d(float64x2_t a)
+        ///   LSX: VFRSQRT.D Vd.2D Vj.2D
+        /// </summary>
+        public static Vector128<double> ReciprocalSqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfsqrt_s(float32x4_t a)
+        ///   LSX: VFSQRT.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Sqrt(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfsqrt_d(float64x2_t a)
+        ///   LSX: VFSQRT.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Sqrt(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vflogb_s(float32x4_t a)
+        ///   LSX: VFLOGB.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> FloatLogarithm2(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vflogb_d(float64x2_t a)
+        ///   LSX: VFLOGB.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> FloatLogarithm2(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(int8x16_t val, int8_t* addr, const short si12)
+        ///   LSX: VST Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(uint8x16_t val, uint8_t* addr, const short si12)
+        ///   LSX: VST Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(int16x8_t val, int16_t* addr, const short si12)
+        ///   LSX: VST Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(uint16x8_t val, uint16_t* addr, const short si12)
+        ///   LSX: VST Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(int32x4_t val, int32_t* addr, const short si12)
+        ///   LSX: VST Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(uint32x4_t val, uint32_t* addr, const short si12)
+        ///   LSX: VST Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(int64x2_t val, int64_t* addr, const short si12)
+        ///   LSX: VST Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(uint64x2_t val, uint64_t* addr, const short si12)
+        ///   LSX: VST Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(float32x4_t val, float32_t* addr, const short si12)
+        ///   LSX: VST Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vst(float64x2_t val, float64_t* addr, const short si12)
+        ///   LSX: VST Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_b(int8x16_t val, int8_t* ptr, const short si8, const byte index)
+        ///   LSX: VSTELM.B Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(15))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_b(uint8x16_t val, uint8_t* ptr, const short si8, const byte index)
+        ///   LSX: VSTELM.B Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(15))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_h(int16x8_t val, int16_t* ptr, const short si9, const byte index) // si9 is 2byte aligned.
+        ///   LSX: VSTELM.H Vd.8H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<short> vector, short* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(7))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_h(uint16x8_t val, uint16_t* ptr, const short si9, const byte index)
+        ///   LSX: VSTELM.H Vd.8H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(7))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_w(int32x4_t val, int* ptr, const short si10, const byte index) // si10 is 4byte aligned.
+        ///   LSX: VSTELM.W Vd.4W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<int> vector, int* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_w(uint32x4_t val, uint* ptr, const short si10, const byte index)
+        ///   LSX: VSTELM.W Vd.4W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_d(int64x2_t val, int64_t* ptr, const short si11, const byte index) // si11 is 8byte aligned.
+        ///   LSX: VSTELM.D Vd.2D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<long> vector, long* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_d(uint64x2_t val, uint64_t* ptr, const short si11, const byte index)
+        ///   LSX: VSTELM.D Vd.2D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_w(float32x4_t val, float32_t* ptr, const short si10, const byte index)
+        ///   LSX: VSTELM.W Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<float> vector, float* addr, [ConstantExpected(Min = -512, Max = 511)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// void vstelm_d(float64x2_t val, float64_t* ptr, const short si11, const byte index)
+        ///   LSX: VSTELM.D Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<double> vector, double* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vneg_b(int8x16_t a)
+        ///   LSX: VNEG.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> Negate(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vneg_h(int16x8_t a)
+        ///   LSX: VNEG.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> Negate(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vneg_w(int32x4_t a)
+        ///   LSX: VNEG.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> Negate(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vneg_d(int64x2_t a)
+        ///   LSX: VNEG.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> Negate(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vbitrevi_w(float32x4_t a)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, 31
+        /// </summary>
+        public static Vector128<float> Negate(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vbitrevi_d(float64x2_t a)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, 63
+        /// </summary>
+        public static Vector128<double> Negate(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t fneg_d(float64x1_t a)
+        ///   LSX: FNEG.D Fd, Fj
+        /// </summary>
+        public static Vector64<double> NegateScalar(Vector64<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32_t fneg_s(float32_t a)
+        ///   LSX: FNEG.S Fd, Fj
+        /// </summary>
+        public static Vector64<float> NegateScalar(Vector64<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmulwod_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningOdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmulwod_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMULWOD.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningOdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmulwod_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMULWOD.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> MultiplyWideningOdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vmulwod_q_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMULWOD.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyWideningOdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vmulwev_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMULWEV.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningEven(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vmulwev_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMULWEV.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningEven(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vmulwev_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMULWEV.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> MultiplyWideningEven(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vmulwev_q_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMULWEV.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyWideningEven(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vmulwod_hu_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMULWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningOdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vmulwod_wu_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMULWOD.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningOdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vmulwod_du_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningOdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vmulwod_qu_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMULWOD.Q.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningOdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// uint16x8_t vmulwev_hu_bu(uint8x16_t a, uint8x16_t b)
+        // ///   LSX: VMULWEV.H.BU Vd.8H, Vj.16B, Vk.16B
+        // /// </summary>
+        // public static Vector128<ushort> MultiplyWideningEven(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// uint32x4_t vmulwev_wu_hu(uint16x8_t a, uint16x8_t b)
+        // ///   LSX: VMULWEV.W.HU Vd.4W, Vj.8H, Vk.8H
+        // /// </summary>
+        // public static Vector128<uint> MultiplyWideningEven(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// uint64x2_t vmulwev_du_wu(uint32x4_t a, uint32x4_t b)
+        // ///   LSX: VMULWEV.D.WU Vd.2D, Vj.4W, Vk.4W
+        // /// </summary>
+        // public static Vector128<ulong> MultiplyWideningEven(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// uint128x1_t vmulwev_qu_du(uint64x2_t a, uint64x2_t b)
+        // ///   LSX: VMULWEV.Q.DU Vd.Q, Vj.2D, Vk.2D
+        // /// </summary>
+        // public static Vector128<ulong> MultiplyWideningEven(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int16x8_t vmulwod_h_bu(uint8x16_t a, int8x16_t b)
+        // ///   LSX: VMULWOD.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        // /// </summary>
+        // public static Vector128<short> MultiplyWideningOdd(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int32x4_t vmulwod_w_hu(uint16x8_t a, int16x8_t b)
+        // ///   LSX: VMULWOD.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        // /// </summary>
+        // public static Vector128<int> MultiplyWideningOdd(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int64x2_t vmulwod_d_wu(uint32x4_t a, int32x4_t b)
+        // ///   LSX: VMULWOD.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningOdd(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int128x1_t vmulwod_q_du(uint64x2_t a, int64x2_t b)
+        // ///   LSX: VMULWOD.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningOdd(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int16x8_t vmulwev_h_bu(uint8x16_t a, int8x16_t b)
+        // ///   LSX: VMULWEV.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        // /// </summary>
+        // public static Vector128<short> MultiplyWideningEven(Vector128<byte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int32x4_t vmulwev_w_hu(uint16x8_t a, int16x8_t b)
+        // ///   LSX: VMULWEV.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        // /// </summary>
+        // public static Vector128<int> MultiplyWideningEven(Vector128<ushort> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int64x2_t vmulwev_d_wu(uint32x4_t a, int32x4_t b)
+        // ///   LSX: VMULWEV.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningEven(Vector128<uint> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        // /// <summary>
+        // /// int128x1_t vmulwev_q_du(uint64x2_t a, int64x2_t b)
+        // ///   LSX: VMULWEV.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningEven(Vector128<ulong> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vavg_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VAVG.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Average(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vavg_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VAVG.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vavg_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VAVG.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Average(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vavg_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VAVG.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vavg_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VAVG.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Average(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vavg_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAVG.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Average(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vavg_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VAVG.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Average(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vavg_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VAVG.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Average(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vavgr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VAVGR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> AverageRounded(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vavgr_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VAVGR.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AverageRounded(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vavgr_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VAVGR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> AverageRounded(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vavgr_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VAVGR.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AverageRounded(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vavgr_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VAVGR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> AverageRounded(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vavgr_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAVGR.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AverageRounded(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vavgr_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VAVGR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AverageRounded(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vavgr_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VAVGR.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AverageRounded(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsllwil_h_b(int8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.H.B Vd.8H, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<short> SignExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsllwil_w_h(int16x4_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.W.H Vd.4W, Vj.4H, ui4
+        /// </summary>
+        public static Vector128<int> SignExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsllwil_d_w(int32x2_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.D.W Vd.2D, Vj.2W, ui5
+        /// </summary>
+        public static Vector128<long> SignExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsllwil_hu_bu(uint8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.HU.BU Vd.8H, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningLowerAndShiftLeft(Vector64<byte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsllwil_hu_bu(int8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.HU.BU Vd.8H, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<short> ZeroExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsllwil_wu_hu(uint16x8_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.WU.HU Vd.4W, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningLowerAndShiftLeft(Vector64<ushort> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsllwil_wu_hu(int16x8_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.WU.HU Vd.4W, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsllwil_du_wu(uint32x4_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.DU.WU Vd.2D, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLowerAndShiftLeft(Vector64<uint> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsllwil_du_wu(int32x4_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.DU.WU Vd.2D, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vextl_qu_du(int64_t a)
+        ///   LSX: VEXTL.QU.DU Vd.Q, Vj.D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vextl_qu_du(uint64_t a)
+        ///   LSX: VEXTL.QU.DU Vd.Q, Vj.D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vexth_h_b(int8x16_t a)
+        ///   LSX: VEXTH.H.B Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> SignExtendWideningUpper(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vexth_w_h(int16x8_t a)
+        ///   LSX: VEXTH.W.H Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> SignExtendWideningUpper(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vexth_d_w(int32x4_t a)
+        ///   LSX: VEXTH.D.W Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> SignExtendWideningUpper(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vexth_d_w(int64x2_t a)
+        ///   LSX: VEXTH.Q.D Vd.Q, Vj.2D
+        /// </summary>
+        public static Vector128<long> SignExtendWideningUpper(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vexth_HU_BU(int8x16_t a)
+        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> ZeroExtendWideningUpper(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vexth_HU_BU(uint8x16_t a)
+        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vexth_WU_HU(int16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vexth_WU_HU(uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vexth_DU_WU(uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vexth_DU_WU(uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int128x1_t vexth_DU_WU(int64x2_t a)
+        ///   LSX: VEXTH.QU.DU Vd.Q, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint128x1_t vexth_DU_WU(uint64x2_t a)
+        ///   LSX: VEXTH.QU.DU Vd.Q, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vand_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vand_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vand_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> And(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vand_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vand_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> And(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vand_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vand_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> And(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vand_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vand_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> And(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vand_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> And(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vandn_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vandn_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vandn_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vandn_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vandn_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vandn_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vandn_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vandn_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vandn_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vandn_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vor(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<byte> Or(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t vor(float64x1_t a, float64x1_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<double> Or(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vor(int16x4_t a, int16x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<short> Or(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vor(int32x2_t a, int32x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<int> Or(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vor(int64x1_t a, int64x1_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<long> Or(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vor(int8x8_t a, int8x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<sbyte> Or(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vor(float32x2_t a, float32x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<float> Or(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vor(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ushort> Or(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vor(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<uint> Or(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vor(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ulong> Or(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vor_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vor_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> Or(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vor_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vor_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vor_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vor_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vor_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vor_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vnori_b(uint8x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<byte> Not(Vector64<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t vnori_b(float64x1_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<double> Not(Vector64<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vnori_b(int16x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<short> Not(Vector64<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vnori_b(int32x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<int> Not(Vector64<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vnori_b(int64x1_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<long> Not(Vector64<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vnori_b(int8x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<sbyte> Not(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vnori_b(float32x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<float> Not(Vector64<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vnori_b(uint16x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<ushort> Not(Vector64<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vnori_b(uint32x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<uint> Not(Vector64<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vnori_b(uint64x1_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<ulong> Not(Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vnori_b(uint8x16_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<byte> Not(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vnori_b(float64x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<double> Not(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vnori_b(int16x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<short> Not(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vnori_b(int32x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<int> Not(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vnori_b(int64x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<long> Not(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vnori_b(int8x16_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<sbyte> Not(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vnori_b(float32x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<float> Not(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vnori_b(uint16x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<ushort> Not(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vnori_b(uint32x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<uint> Not(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vnori_b(uint64x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
+        /// </summary>
+        public static Vector128<ulong> Not(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vnor_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VNOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> NotOr(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vnor_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VNOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> NotOr(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vnor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VNOR.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> NotOr(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vnor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VNOR.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> NotOr(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vnor_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VNOR.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> NotOr(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vnor_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VNOR.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> NotOr(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vnor_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VNOR.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> NotOr(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vnor_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VNOR.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> NotOr(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vnor_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VNOR.V Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> NotOr(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vnor_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VNOR.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> NotOr(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vorn(uint8x8_t a, uint8x8_t b)
+        /// </summary>
+        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t vorn(float64x1_t a, float64x1_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vorn(int16x4_t a, int16x4_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vorn(int32x2_t a, int32x2_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vorn(int64x1_t a, int64x1_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vorn(int8x8_t a, int8x8_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vorn(float32x2_t a, float32x2_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vorn(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vorn(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vorn(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vorn_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> OrNot(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vorn_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> OrNot(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VORN.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> OrNot(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VORN.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> OrNot(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vorn_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VORN.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> OrNot(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vorn_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VORN.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> OrNot(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vorn_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VORN.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> OrNot(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vorn_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VORN.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> OrNot(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vorn_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VORN.V Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> OrNot(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vorn_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VORN.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> OrNot(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vxor(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<byte> Xor(Vector64<byte> left, Vector64<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x1_t vxor(float64x1_t a, float64x1_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<double> Xor(Vector64<double> left, Vector64<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vxor(int16x4_t a, int16x4_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<short> Xor(Vector64<short> left, Vector64<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vxor(int32x2_t a, int32x2_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<int> Xor(Vector64<int> left, Vector64<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vxor(int64x1_t a, int64x1_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<long> Xor(Vector64<long> left, Vector64<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vxor(int8x8_t a, int8x8_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<sbyte> Xor(Vector64<sbyte> left, Vector64<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x2_t vxor(float32x2_t a, float32x2_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<float> Xor(Vector64<float> left, Vector64<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vxor(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<ushort> Xor(Vector64<ushort> left, Vector64<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vxor(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<uint> Xor(Vector64<uint> left, Vector64<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vxor(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<ulong> Xor(Vector64<ulong> left, Vector64<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vxor_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vxor_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vxor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vxor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vxor_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vxor_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vxor_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vxor_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vxor_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vxor_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vslli_b(int8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vslli_b(uint8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vslli_h(int16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vslli_h(uint16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslli_w(uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vslli_w(uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vslli_d(int64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vslli_d(uint64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbsll_v(int8x16_t a, const int shift)
+        ///   LSX: VBSLL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogicalByByte(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbsll_v(uint8x16_t a, const int shift)
+        ///   LSX: VBSLL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogicalByByte(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsll_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, Vector128<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsll_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, Vector128<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsll_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSLL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsll_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSLL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsll_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSLL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsll_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSLL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsll_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSLL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsll_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSLL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrli_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrli_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrli_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrli_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrli_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrli_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrli_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrli_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbsrl_v(int8x16_t a, const int shift)
+        ///   LSX: VBSRL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalByByte(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbsrl_v(uint8x16_t a, const int shift)
+        ///   LSX: VBSRL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalByByte(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrl_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSRL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, Vector128<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrl_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSRL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, Vector128<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrl_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrl_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrl_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrl_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrl_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrl_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrlr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSRLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, Vector128<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSRLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, Vector128<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrlr_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlr_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrlr_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlr_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrlr_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsrlr_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlrni_b_h(uint16x8_t left, uint16x8_t right, const int n)
+        ///   LSX: VSRLRNI.B.H Vd, Vj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrlrni_b_h(int16x8_t left, int16x8_t right, const int n)
+        ///   LSX: VSRLRNI.B.H Vd, Vj, ui4
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrlrni_h_w(int32x4_t left, int32x4_t right, const int n)
+        ///   LSX: VSRLRNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlrni_h_w(uint32x4_t left, uint32x4_t right, const int n)
+        ///   LSX: VSRLRNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrlrni_w_d(int64x2_t left, int64x2_t right, const int n)
+        ///   LSX: VSRLRNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlrni_w_d(uint64x2_t left, uint64x2_t right, const int n)
+        ///   LSX: VSRLRNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vsrlrni_d_q(int128x1_t left, int128x1_t right, const int n)
+        /////   LSX: VSRLRNI.D.Q Vd, Vj, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vsrlrn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vsrlrn_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vsrlrn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vsrlrn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vsrlrn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vsrlrn_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrai_b(int8x16_t a, const int n)
+        ///   LSX: VSRAI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrai_h(int16x8_t a, const int n)
+        ///   LSX: VSRAI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrai_w(int32x4_t a, const int n)
+        ///   LSX: VSRAI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrai_d(int64x2_t a, const int n)
+        ///   LSX: VSRAI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsra_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSRA.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmetic(Vector128<byte> value, Vector128<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsra_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRA.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsra_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRA.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsra_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRA.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrari_b(int8x16_t a, const int n)
+        ///   LSX: VSRARI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrari_h(int16x8_t a, const int n)
+        ///   LSX: VSRARI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrari_w(int32x4_t a, const int n)
+        ///   LSX: VSRARI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrari_d(int64x2_t a, const int n)
+        ///   LSX: VSRARI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrar_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSRAR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, Vector128<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrar_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRAR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrar_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRAR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsrar_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRAR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsrarni_b_h(int16x8_t left, int16x8_t right, const int n)
+        ///   LSX: VSRARNI.B.H Vd, Vj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrarni_h_w(int32x4_t left, int32x4_t right, const int n)
+        ///   LSX: VSRARNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrarni_w_d(int64x2_t left, int64x2_t right, const int n)
+        ///   LSX: VSRARNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vsrarni_d_q(int128x1_t left, int128x1_t right, const int n)
+        /////   LSX: VSRARNI.D.Q Vd, Vj, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vsrarn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRARN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vsrarn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRARN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vsrarn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRARN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vsrarn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRARN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vrotri_b(uint8x16_t a, const int n)
+        ///   LSX: VROTRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> RotateRight(Vector128<sbyte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vrotri_b(uint8x16_t a, const int n)
+        ///   LSX: VROTRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> RotateRight(Vector128<byte> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vrotri_h(uint16x8_t a, const int n)
+        ///   LSX: VROTRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> RotateRight(Vector128<short> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vrotri_h(uint16x8_t a, const int n)
+        ///   LSX: VROTRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> RotateRight(Vector128<ushort> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vrotri_w(uint32x4_t a, const int n)
+        ///   LSX: VROTRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> RotateRight(Vector128<int> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vrotri_w(uint32x4_t a, const int n)
+        ///   LSX: VROTRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> RotateRight(Vector128<uint> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vrotri_d(uint64x2_t a, const int n)
+        ///   LSX: VROTRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> RotateRight(Vector128<long> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vrotri_d(uint64x2_t a, const int n)
+        ///   LSX: VROTRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> RotateRight(Vector128<ulong> value, const byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vrotr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VROTR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> RotateRight(Vector128<sbyte> value, Vector128<sbyte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vrotr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VROTR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> RotateRight(Vector128<byte> value, Vector128<byte> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vrotr_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VROTR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> RotateRight(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vrotr_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VROTR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> RotateRight(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vrotr_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VROTR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> RotateRight(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vrotr_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VROTR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> RotateRight(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vrotr_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VROTR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> RotateRight(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vrotr_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VROTR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> RotateRight(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsigncov_b(int8x16_t a)
+        ///   LSX: VSIGNCOV.B Vd.16B, Vj.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> Abs(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsigncov_h(int16x8_t a)
+        ///   LSX: VSIGNCOV.H Vd.8H, Vj.8H, Vj.8H
+        /// </summary>
+        public static Vector128<ushort> Abs(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsigncov_w(int32x4_t a)
+        ///   LSX: VSIGNCOV.W Vd.4W, Vj.4W, Vj.4W
+        /// </summary>
+        public static Vector128<uint> Abs(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsigncov_d(int64x2_t a)
+        ///   LSX: VSIGNCOV.D Vd.2D, Vj.2D, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> Abs(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vbitclri_w(float32x4_t a)
+        ///   LSX: VBITCLRI.W Vd.4S, Vj.4S, 31
+        /// </summary>
+        public static Vector128<float> Abs(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vbitclri_d(float64x2_t a)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, 63
+        /// </summary>
+        public static Vector128<double> Abs(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrintrm_s(float32x4_t a)
+        ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Floor(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrintrm_d(float64x2_t a)
+        ///   LSX: VFRINTRM.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Floor(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrintrp_s(float32x4_t a)
+        ///   LSX: VFRINTRP.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Ceiling(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrintrp_d(float64x2_t a)
+        ///   LSX: VFRINTRP.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Ceiling(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrintrz_s(float32x4_t a)
+        ///   LSX: VFRINTRZ.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> RoundToZero(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrintrz_d(float64x2_t a)
+        ///   LSX: VFRINTRZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> RoundToZero(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrintrm_s(float32x4_t a)
+        ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrintrm_d(float64x2_t a)
+        ///   LSX: VFRINTRM.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vfrintrp_s(float32x4_t a)
+        ///   LSX: VFRINTRP.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vfrintrp_d(float64x2_t a)
+        ///   LSX: VFRINTRP.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vinsgr2vr_b(int8x16_t v, int8_t data, const int index)
+        ///   LSX: VINSGR2VR.B Vd.B, Rj, ui4
+        /// </summary>
+        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, sbyte data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vinsgr2vr_b(uint8x16_t v, uint8_t data, const int index)
+        ///   LSX: VINSGR2VR.B Vd.B, Rj, ui4
+        /// </summary>
+        public static Vector128<byte> Insert(Vector128<byte> vector, byte data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vinsgr2vr_h(int16x8_t v, int16_t data, const int index)
+        ///   LSX: VINSGR2VR.H Vd.H, Rj, ui3
+        /// </summary>
+        public static Vector128<short> Insert(Vector128<short> vector, short data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vinsgr2vr_h(uint16x8_t v, uint16_t data, const int index)
+        ///   LSX: VINSGR2VR.H Vd.H, Rj, ui3
+        /// </summary>
+        public static Vector128<ushort> Insert(Vector128<ushort> vector, ushort data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vinsgr2vr_w(int32x4_t v, int32_t data, const int index)
+        ///   LSX: VINSGR2VR.W Vd.S, Rj, ui2
+        /// </summary>
+        public static Vector128<int> Insert(Vector128<int> vector, int data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vinsgr2vr_w(uint32x4_t v, uint32_t data, const int index)
+        ///   LSX: VINSGR2VR.W Vd.S, Rj, ui2
+        /// </summary>
+        public static Vector128<uint> Insert(Vector128<uint> vector, uint data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vinsgr2vr_d(int64x2_t v, int64_t data, const int index)
+        ///   LSX: VINSGR2VR.D Vd.D, Rj, ui1
+        /// </summary>
+        public static Vector128<long> Insert(Vector128<long> vector, long data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vinsgr2vr_d(uint64x2_t v, uint64_t data, const int index)
+        ///   LSX: VINSGR2VR.D Vd.D, Rj, ui1
+        /// </summary>
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, ulong data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t xvinsve0_w(float32x4_t v, float32_t data, const int index)
+        ///   LSX: VEXTRINS.W  Vd.S, Vj.S, ui8
+        /// </summary>
+        public static Vector128<float> Insert(Vector128<float> vector, float data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t xvinsve0_d(float64x2_t v, float64_t data, const int index)
+        ///   LSX: VEXTRINS.D  Vd.D, Vj.D, ui8
+        /// </summary>
+        public static Vector128<double> Insert(Vector128<double> vector, double data, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vreplgr2vr_b(int8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// </summary>
+        public static Vector128<sbyte> DuplicateToVector128(sbyte value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vreplgr2vr_b(uint8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// </summary>
+        public static Vector128<byte> DuplicateToVector128(byte value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vreplgr2vr_h(int16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// </summary>
+        public static Vector128<short> DuplicateToVector128(short value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vreplgr2vr_h(uint16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// </summary>
+        public static Vector128<ushort> DuplicateToVector128(ushort value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vreplgr2vr_w(int32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
+        /// </summary>
+        public static Vector128<int> DuplicateToVector128(int value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vreplgr2vr_w(uint32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
+        /// </summary>
+        public static Vector128<uint> DuplicateToVector128(uint value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vreplgr2vr_d(int64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// </summary>
+        public static Vector128<long> DuplicateToVector128(long value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vreplgr2vr_d(uint64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// </summary>
+        public static Vector128<ulong> DuplicateToVector128(ulong value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t xvreplve0_w(float32_t value)
+        ///   LSX: XVREPLVE0.W Vd.4S, Vj.S[0]
+        /// </summary>
+        public static Vector128<float> DuplicateToVector128(float value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t xvreplve0_d(float64_t value)
+        ///   LSX: XVREPLVE0.D Vd.2D, Vj.D[0]
+        /// </summary>
+        public static Vector128<double> DuplicateToVector128(double value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vffint_s_w(int32x4_t a)
+        ///   LSX: VFFINT.S.W Vd.4S, Vj.4W
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float32x4_t vffint_s_wu(uint32x4_t a)
+        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4W
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vffint_d_l(int64x2_t a)
+        ///   LSX: VFFINT.D.L Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> ConvertToDouble(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// float64x2_t vffint_d_lu(uint64x2_t a)
+        ///   LSX: VFFINT.D.LU Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> ConvertToDouble(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8_t vfsrtpi_b(uint8x16_t value)
+        ///   LSX: VFSRTPI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static byte FirstNegativeInteger(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16_t vfsrtpi_h(uint16x8_t value)
+        ///   LSX: VFSRTPI.H Vd.8H, Vj.8H, 0
+        /// </summary>
+        public static ushort FirstNegativeInteger(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetnez_v(uint8x16_t value)
+        ///   LSX: VSETNEZ.V cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vseteqz_v(uint8x16_t value)
+        ///   LSX: VSETEQZ.V cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_b(int8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_b(uint8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_h(int16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_h(uint16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w(int32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w(uint32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w(int64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetallnez_w(uint64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_b(int8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_b(uint8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_h(int16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_h(uint16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w(int32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w(uint32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w(int64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// bool vsetanyeqz_w(uint64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsrlni_b_h(uint16x8_t left, uint16x8_t right, shift)
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsrlni_h_w(int32x4_t left, int32x4_t right, shift)
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsrlni_h_w(uint32x4_t left, uint32x4_t right, shift)
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsrlni_w_d(int64x2_t left, int64x2_t right, shift)
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsrlni_w_d(uint64x2_t left, uint64x2_t right, shift)
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vsrlni_d_q(uint128x1_t left, uint128x1_t right, shift)
+        /////   LSX: VSRLNI.D.Q Vd.Q, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightLogicalNarrowingLower(Vector128<ulonglong> left, Vector128<ulonglong> right, byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vsrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vsrln_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vsrln_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vsrln_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vsrln_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vsrln_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssrlni_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRLNI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlni_b_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLNI.B.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssrlni_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRLNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlni_h_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vssrlni_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRLNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssrlni_w_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vssrlni_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRLNI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightLogicalNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vssrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vssrln_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vssrln_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vssrln_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vssrln_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vssrln_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlni_bu_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLNI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlni_hu_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLNI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssrlni_wu_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLNI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vssrlni_du_q(uint128x1_t left, uint128x1_t right, const byte n)
+        /////   LSX: VSSRLNI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulonglong> left, Vector128<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vssrln_bu_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vssrln_hu_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vssrln_wu_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssran_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRANI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssran_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRANI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vssran_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRANI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vssran_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRANI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightArithmeticNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vssran_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRAN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vssran_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRAN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vssran_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRAN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrani_bu_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRANI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrani_hu_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRANI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssrani_wu_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRANI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vssrani_du_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRANI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vssran_bu_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRAN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vssran_hu_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRAN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vssran_wu_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRAN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssrlrni_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRLRNI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_b_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLRNI.B.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssrlrni_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRLRNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_h_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLRNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vssrlrni_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRLRNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssrlrni_w_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLRNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vssrlrni_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRLRNI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vssrlrn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vssrlrn_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vssrlrn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vssrlrn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vssrlrn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vssrlrn_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_bu_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLRNI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_hu_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLRNI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssrlrni_wu_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLRNI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vssrlrni_du_q(uint128x1_t left, uint128x1_t right, const byte n)
+        /////   LSX: VSSRLRNI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulonglong> left, Vector128<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vssrlrn_bu_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLRN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vssrlrn_hu_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLRN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vssrlrn_wu_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLRN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssrarn_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRARNI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vssrarn_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRARNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vssrarn_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRARNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// int64x2_t vssrarn_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRARNI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vssrarn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRARN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vssrarn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRARN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vssrarn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRARN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrarni_bu_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRARNI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vssrarni_hu_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRARNI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vssrarni_wu_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRARNI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        ///// <summary>
+        ///// uint64x2_t vssrarni_du_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRARNI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vssrarn_bu_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRARN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vssrarn_hu_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRARN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vssrarn_wu_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRARN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vclo_b(int8x8_t a)
+        ///   LSX: VCLO.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vclo_h(int16x4_t a)
+        ///   LSX: VCLO.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<short> LeadingSignCount(Vector64<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vclo_w(int32x2_t a)
+        ///   LSX: VCLO.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<int> LeadingSignCount(Vector64<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vclo_d(int64x1_t a)
+        ///   LSX: VCLO.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<long> LeadingSignCount(Vector64<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vclo_b(int8x16_t a)
+        ///   LSX: VCLO.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vclo_h(int16x8_t a)
+        ///   LSX: VCLO.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> LeadingSignCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vclo_w(int32x4_t a)
+        ///   LSX: VCLO.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> LeadingSignCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vclo_d(int64x2_t a)
+        ///   LSX: VCLO.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> LeadingSignCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x8_t vclz_b(uint8x8_t a)
+        ///   LSX: VCLZ.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x8_t vclz_b(int8x8_t a)
+        ///   LSX: VCLZ.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x4_t vclz_h(int16x4_t a)
+        ///   LSX: VCLZ.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<short> LeadingZeroCount(Vector64<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x4_t vclz_h(uint16x4_t a)
+        ///   LSX: VCLZ.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x2_t vclz_w(int32x2_t a)
+        ///   LSX: VCLZ.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<int> LeadingZeroCount(Vector64<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x2_t vclz_w(uint32x2_t a)
+        ///   LSX: VCLZ.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x1_t vclz_d(int64x1_t a)
+        ///   LSX: VCLZ.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<long> LeadingZeroCount(Vector64<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x1_t vclz_d(uint64x1_t a)
+        ///   LSX: VCLZ.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<ulong> LeadingZeroCount(Vector64<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vclz_b(int8x16_t a)
+        ///   LSX: VCLZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vclz_b(uint8x16_t a)
+        ///   LSX: VCLZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vclz_h(int16x8_t a)
+        ///   LSX: VCLZ.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> LeadingZeroCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vclz_h(uint16x8_t a)
+        ///   LSX: VCLZ.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vclz_w(int32x4_t a)
+        ///   LSX: VCLZ.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> LeadingZeroCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vclz_w(uint32x4_t a)
+        ///   LSX: VCLZ.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vclz_d(int64x2_t a)
+        ///   LSX: VCLZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> LeadingZeroCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vclz_d(uint64x2_t a)
+        ///   LSX: VCLZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vpcnt_b(int8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vpcnt_b(uint8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<byte> PopCount(Vector128<byte> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vpcnt_h(int16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<short> PopCount(Vector128<short> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vpcnt_h(uint16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<ushort> PopCount(Vector128<ushort> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vpcnt_w(int32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<int> PopCount(Vector128<int> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vpcnt_w(uint32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<uint> PopCount(Vector128<uint> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vpcnt_d(int64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<long> PopCount(Vector128<long> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vpcnt_d(uint64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<ulong> PopCount(Vector128<ulong> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vshuf_b(uint8x16_t vec, uint8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector, Vector128<byte> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vshuf_b(int8x16_t vec, int8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector, Vector128<sbyte> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vshuf_b(uint8x16_t vec0, uint8x16_t vec1, uint8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector0, Vector128<byte> vector1, Vector128<byte> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vshuf_b(int8x16_t vec0, int8x16_t vec1, int8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector0, Vector128<sbyte> vector1, Vector128<sbyte> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vshuf_h(int16x8_t vec0, int16x8_t vec1, int16x8_t idx)
+        ///   LSX: VSHUF.H Vd.8H, Vj.8H, Vk.8H                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vshuf_h(uint16x8_t vecj, uint16x8_t veck, uint16x8_t idx)
+        ///   LSX: VSHUF.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector0, Vector128<ushort> vector1, Vector128<ushort> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vpermi_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<int> VectorShuffle(Vector128<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vpermi_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vshuf_w(int32x4_t vec0, int32x4_t vec1, int32x4_t idx)
+        ///   LSX: VSHUF.W Vd.4W, Vj.4W, Vk.4W                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vshuf_w(uint32x4_t vecj, uint32x4_t veck, uint32x4_t idx)
+        ///   LSX: VSHUF.W Vd.4W, Vj.4W, Vk.4W                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vshuf_d(int64x2_t vec0, int64x2_t vec1, int64x2_t idx)
+        ///   LSX: VSHUF.D Vd.2D, Vj.2D, Vk.2D                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vshuf_d(uint64x2_t vecj, uint64x2_t veck, uint64x2_t idx)
+        ///   LSX: VSHUF.D Vd.2D, Vj.2D, Vk.2D                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vshuf4i_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<sbyte> VectorShuffleBy4Elements(Vector128<sbyte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vshuf4i_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<byte> VectorShuffleBy4Elements(Vector128<byte> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vshuf4i_h(int16x8_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<short> VectorShuffleBy4Elements(Vector128<short> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vshuf4i_h(uint16x8_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<ushort> VectorShuffleBy4Elements(Vector128<ushort> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vshuf4i_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<int> VectorShuffleBy4Elements(Vector128<int> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vshuf4i_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<uint> VectorShuffleBy4Elements(Vector128<uint> vector, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vshuf4i_d(int64x2_t vec0, uint64x2_t vec1, uint8_t idx)
+        ///   LSX: VSHUF4I.D Vd.2D, Vj.2D, ui4
+        /// </summary>
+        public static Vector128<long> VectorShuffleBy4Elements(Vector128<long> vector0, Vector128<long> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vshuf4i_d(uint64x2_t vec0, uint64x2_t vec1, uint8_t idx)
+        ///   LSX: VSHUF4I.D Vd.2D, Vj.2D, ui4
+        /// </summary>
+        public static Vector128<ulong> VectorShuffleBy4Elements(Vector128<ulong> vector0, Vector128<ulong> vector1, byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vilvl_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VILVL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionLower(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vilvl_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VILVL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionLower(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vilvl_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VILVL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionLower(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vilvl_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VILVL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionLower(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vilvl_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VILVL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionLower(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vilvl_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VILVL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionLower(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vilvl_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VILVL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionLower(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vilvl_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VILVL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionLower(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vilvh_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VILVH.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionHight(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vilvh_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VILVH.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionHight(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vilvh_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VILVH.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionHight(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vilvh_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VILVH.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionHight(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vilvh_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VILVH.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionHight(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vilvh_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VILVH.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionHight(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vilvh_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VILVH.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionHight(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vilvh_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VILVH.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionHight(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vpackev_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPACKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionEven(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vpackev_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPACKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionEven(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vpackev_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPACKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionEven(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vpackev_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPACKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionEven(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vpackev_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPACKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionEven(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vpackev_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPACKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionEven(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vpackev_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPACKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionEven(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vpackev_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPACKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionEven(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vpackod_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPACKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionOdd(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vpackod_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPACKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionOdd(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vpackod_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPACKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionOdd(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vpackod_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPACKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionOdd(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vpackod_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPACKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionOdd(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vpackod_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPACKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionOdd(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vpackod_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPACKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionOdd(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vpackod_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPACKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionOdd(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vpickev_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPICKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorEvenElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vpickev_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPICKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorEvenElementsJoin(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vpickev_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPICKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorEvenElementsJoin(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vpickev_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPICKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorEvenElementsJoin(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vpickev_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPICKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorEvenElementsJoin(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vpickev_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPICKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorEvenElementsJoin(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vpickev_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPICKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorEvenElementsJoin(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vpickev_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPICKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorEvenElementsJoin(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vpickod_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPICKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorOddElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vpickod_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPICKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorOddElementsJoin(Vector128<byte> left, Vector128<byte> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vpickod_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPICKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorOddElementsJoin(Vector128<short> left, Vector128<short> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vpickod_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPICKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorOddElementsJoin(Vector128<ushort> left, Vector128<ushort> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vpickod_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPICKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorOddElementsJoin(Vector128<int> left, Vector128<int> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vpickod_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPICKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorOddElementsJoin(Vector128<uint> left, Vector128<uint> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vpickod_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPICKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorOddElementsJoin(Vector128<long> left, Vector128<long> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vpickod_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPICKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorOddElementsJoin(Vector128<ulong> left, Vector128<ulong> right) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vreplve_b(uint8x16_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.B Vd.16B, Vj.16B, rk
+        ///   LSX: VREPLVEI.B Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<byte> VectorElementReplicate(Vector128<byte> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vreplve_b(int8x16_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.B Vd.16B, Vj.16B, rk
+        ///   LSX: VREPLVEI.B Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> VectorElementReplicate(Vector128<sbyte> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vreplve_h(int16x8_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.H Vd.8H, Vj.8H, rk
+        ///   LSX: VREPLVEI.H Vd.8H, Vj.8H, ui3
+        /// </summary>
+        public static Vector128<short> VectorElementReplicate(Vector128<short> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vreplve_h(uint16x8_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.H Vd.8H, Vj.8H, rk
+        ///   LSX: VREPLVEI.H Vd.8H, Vj.8H, ui3
+        /// </summary>
+        public static Vector128<ushort> VectorElementReplicate(Vector128<ushort> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vreplve_w(int32x4_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.W Vd.4W, Vj.4W, rk
+        ///   LSX: VREPLVEI.W Vd.4W, Vj.4W, ui2
+        /// </summary>
+        public static Vector128<int> VectorElementReplicate(Vector128<int> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vreplve_w(uint32x4_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.W Vd.4W, Vj.4W, rk
+        ///   LSX: VREPLVEI.W Vd.4W, Vj.4W, ui2
+        /// </summary>
+        public static Vector128<uint> VectorElementReplicate(Vector128<uint> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vreplve_d(int64x2_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.D Vd.2D, Vj.2D, rk
+        ///   LSX: VREPLVEI.D Vd.2D, Vj.2D, ui1
+        /// </summary>
+        public static Vector128<long> VectorElementReplicate(Vector128<long> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vreplve_d(uint64x2_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.D Vd.2D, Vj.2D, rk
+        ///   LSX: VREPLVEI.D Vd.2D, Vj.2D, ui1
+        /// </summary>
+        public static Vector128<ulong> VectorElementReplicate(Vector128<ulong> vector, byte elementIndexe) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vextrins_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<sbyte> UpdateOneVectorElement(Vector128<sbyte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint8x16_t vextrins_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<byte> UpdateOneVectorElement(Vector128<byte> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vextrins_h(int16x8_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<short> UpdateOneVectorElement(Vector128<short> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint16x8_t vextrins_h(uint16x8_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<ushort> UpdateOneVectorElement(Vector128<ushort> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vextrins_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<int> UpdateOneVectorElement(Vector128<int> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint32x4_t vextrins_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<uint> UpdateOneVectorElement(Vector128<uint> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vextrins_d(int64x2_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.D Vd.2D, Vj.2D, ui8
+        /// </summary>
+        public static Vector128<long> UpdateOneVectorElement(Vector128<long> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  uint64x2_t vextrins_d(uint64x2_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.D Vd.2D, Vj.2D, ui8
+        /// </summary>
+        public static Vector128<ulong> UpdateOneVectorElement(Vector128<ulong> vector, const byte indexs) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int8x16_t vsigncov_b(int8x16_t sign, int8x16_t data)
+        ///   LSX: VSIGNCOV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementNegatedBySign(Vector128<sbyte> sign, Vector128<sbyte> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int16x8_t vsigncov_h(int16x8_t sign, int16x8_t data)
+        ///   LSX: VSIGNCOV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementNegatedBySign(Vector128<short> sign, Vector128<short> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int32x4_t vsigncov_w(int32x4_t sign, int32x4_t data)
+        ///   LSX: VSIGNCOV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementNegatedBySign(Vector128<int> sign, Vector128<int> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        ///  int64x2_t vsigncov_d(int64x2_t sign, int64x2_t data)
+        ///   LSX: VSIGNCOV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementNegatedBySign(Vector128<long> sign, Vector128<long> data) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitclri_b(int8x16_t a, const int n)
+        ///   LSX: VBITCLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitclri_b(uint8x16_t a, const int n)
+        ///   LSX: VBITCLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitclri_h(int16x8_t a, const int n)
+        ///   LSX: VBITCLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorElementBitClear(Vector128<short> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitclri_h(uint16x8_t a, const int n)
+        ///   LSX: VBITCLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorElementBitClear(Vector128<int> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitclri_d(int64x2_t a, const int n)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorElementBitClear(Vector128<long> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitclri_d(uint64x2_t a, const int n)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitclr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITCLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, Vector128<sbyte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitclr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITCLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, Vector128<byte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitclr_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITCLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementBitClear(Vector128<short> value, Vector128<short> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitclr_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITCLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, Vector128<ushort> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vbitclr_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITCLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementBitClear(Vector128<int> value, Vector128<int> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitclr_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITCLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, Vector128<uint> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitclr_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITCLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementBitClear(Vector128<long> value, Vector128<long> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitclr_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITCLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, Vector128<ulong> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitseti_b(int8x16_t a, const int n)
+        ///   LSX: VBITSETI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitseti_b(uint8x16_t a, const int n)
+        ///   LSX: VBITSETI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitseti_h(int16x8_t a, const int n)
+        ///   LSX: VBITSETI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorElementBitSet(Vector128<short> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitseti_h(uint16x8_t a, const int n)
+        ///   LSX: VBITSETI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorElementBitSet(Vector128<int> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitseti_d(int64x2_t a, const int n)
+        ///   LSX: VBITSETI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorElementBitSet(Vector128<long> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitseti_d(uint64x2_t a, const int n)
+        ///   LSX: VBITSETI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitset_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITSET.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, Vector128<sbyte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitset_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITSET.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, Vector128<byte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitset_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITSET.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementBitSet(Vector128<short> value, Vector128<short> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitset_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITSET.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, Vector128<ushort> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vbitset_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITSET.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementBitSet(Vector128<int> value, Vector128<int> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitset_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITSET.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, Vector128<uint> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitset_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITSET.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementBitSet(Vector128<long> value, Vector128<long> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitset_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITSET.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, Vector128<ulong> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitrevi_b(int8x16_t a, const int n)
+        ///   LSX: VBITREVI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitrevi_b(uint8x16_t a, const int n)
+        ///   LSX: VBITREVI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitrevi_h(int16x8_t a, const int n)
+        ///   LSX: VBITREVI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitrevi_h(uint16x8_t a, const int n)
+        ///   LSX: VBITREVI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitrevi_w(uint32x4_t a, const int n)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitrevi_w(uint32x4_t a, const int n)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitrevi_d(int64x2_t a, const int n)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitrevi_d(uint64x2_t a, const int n)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, const byte index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vbitrev_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITREV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, Vector128<sbyte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vbitrev_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITREV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, Vector128<byte> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vbitrev_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITREV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, Vector128<short> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vbitrev_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITREV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, Vector128<ushort> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vbitrev_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITREV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, Vector128<int> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vbitrev_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITREV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, Vector128<uint> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vbitrev_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITREV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, Vector128<long> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vbitrev_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITREV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, Vector128<ulong> index) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vfrstp_b(int8x16_t value, int8x16_t save)
+        ///   LSX: VFRSTP.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, Vector128<sbyte> save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vfrstp_h(int16x8_t value, int16x8_t save)
+        ///   LSX: VFRSTP.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, Vector128<short> save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vfrstpi_b(int8x16_t value, uint8_t save)
+        ///   LSX: VFRSTPI.B Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, const byte save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vfrstpi_h(int16x8_t value, uint8_t save)
+        ///   LSX: VFRSTPI.H Vd.8H, Vj.8H, ui3
+        /// </summary>
+        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, const byte save) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int8x16_t vsat_b(int8x16_t value, uint8_t ui3)
+        ///   LSX: VSAT.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int16x8_t vsat_h(int16x8_t value, uint8_t ui4)
+        ///   LSX: VSAT.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vsat_w(int32x4_t value, uint8_t ui5)
+        ///   LSX: VSAT.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorSaturate(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vsat_d(int64x2_t value, uint8_t ui6)
+        ///   LSX: VSAT.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint8x16_t vsat_bu(uint8x16_t value, uint8_t ui3)
+        ///   LSX: VSAT.BU Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorSaturateUnsigned(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint16x8_t vsat_hu(uint16x8_t value, uint8_t ui4)
+        ///   LSX: VSAT.HU Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorSaturateUnsigned(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint32x4_t vsat_wu(uint32x4_t value, uint8_t ui5)
+        ///   LSX: VSAT.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorSaturateUnsigned(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// uint64x2_t vsat_du(uint64x2_t value, uint8_t ui6)
+        ///   LSX: VSAT.DU Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorSaturateUnsigned(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte bits) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int32x4_t vfclass_s(float32x4_t a)
+        ///   LSX: VFCLASS.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<int> FloatClass(Vector128<float> value) { throw new PlatformNotSupportedException(); }
+
+        /// <summary>
+        /// int64x2_t vfclass_d(float64x2_t a)
+        ///   LSX: VFCLASS.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> FloatClass(Vector128<double> value) { throw new PlatformNotSupportedException(); }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs
new file mode 100644
index 00000000000000..5d6595af3a391d
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/LoongArch/Lsx.cs
@@ -0,0 +1,5937 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    /// <summary>
+    /// This class provides access to the LSX-128bits hardware instructions via intrinsics
+    /// </summary>
+    [Intrinsic]
+    [CLSCompliant(false)]
+    public abstract class Lsx : LoongArchBase
+    {
+        internal Lsx() { }
+
+        public static new bool IsSupported { get => IsSupported; }
+
+        /// <summary>
+        /// int8x8_t vadd_b(int8x8_t a, int8x8_t b)
+        ///   LSX: VADD.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right) => Add(left, right);
+
+        /// <summary>
+        /// uint8x8_t vadd_b(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VADD.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right) => Add(left, right);
+
+        /// <summary>
+        /// int16x4_t vadd_h(int16x4_t a, int16x4_t b)
+        ///   LSX: VADD.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<short> Add(Vector64<short> left, Vector64<short> right) => Add(left, right);
+
+        /// <summary>
+        /// uint16x4_t vadd_h(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VADD.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right) => Add(left, right);
+
+        /// <summary>
+        /// int32x2_t vadd_w(int32x2_t a, int32x2_t b)
+        ///   LSX: VADD.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<int> Add(Vector64<int> left, Vector64<int> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x2_t vadd_w(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VADD.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// int64x1_t vadd_d(int64x1_t a, int64x1_t b)
+        ///   LSX: VADD.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<long> Add(Vector64<long> left, Vector64<long> right) => Add(left, right);
+
+        /// <summary>
+        /// uint64x1_t vadd_d(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VADD.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<ulong> Add(Vector64<ulong> left, Vector64<ulong> right) => Add(left, right);
+
+        /// <summary>
+        /// float32x2_t vfadd_s(float32x2_t a, float32x2_t b)
+        ///   LSX: VFADD.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector64<float> Add(Vector64<float> left, Vector64<float> right) => Add(left, right);
+
+        /// <summary>
+        /// float64x1_t vfadd_d(float64x1_t a, float64x1_t b)
+        ///   LSX: VFADD.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<double> Add(Vector64<double> left, Vector64<double> right) => Add(left, right);
+
+        /// <summary>
+        /// int8x16_t vadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right) => Add(left, right);
+
+        /// <summary>
+        /// uint8x16_t vadd_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right) => Add(left, right);
+
+        /// <summary>
+        /// int16x8_t vadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Add(Vector128<short> left, Vector128<short> right) => Add(left, right);
+
+        /// <summary>
+        /// uint16x8_t vadd_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right) => Add(left, right);
+
+        /// <summary>
+        /// int32x4_t vadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Add(Vector128<int> left, Vector128<int> right) => Add(left, right);
+
+        /// <summary>
+        /// uint32x4_t vadd_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right) => Add(left, right);
+
+        /// <summary>
+        /// int64x2_t vadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Add(Vector128<long> left, Vector128<long> right) => Add(left, right);
+
+        /// <summary>
+        /// uint64x2_t vadd_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right) => Add(left, right);
+
+        /// <summary>
+        /// float32x4_t vfadd_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFADD.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Add(Vector128<float> left, Vector128<float> right) => Add(left, right);
+
+        /// <summary>
+        /// float64x2_t vfadd_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Add(Vector128<double> left, Vector128<double> right) => Add(left, right);
+
+        /// <summary>
+        /// int8x8_t vsadd_b(int8x8_t a, uint8x8_t b)
+        ///   LSX: VSADD.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<byte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint8x8_t vsadd_bu(uint8x8_t a, int8x8_t b)
+        ///   LSX: VSADD.BU Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<sbyte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x4_t vsadd_h(int16x4_t a, uint16x4_t b)
+        ///   LSX: VSADD.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<ushort> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint16x4_t vsadd_hu(uint16x4_t a, int16x4_t b)
+        ///   LSX: VSADD.HU Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<short> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int32x2_t vsadd_w(int32x2_t a, uint32x2_t b)
+        ///   LSX: VSADD.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint32x2_t vsadd_wu(uint32x2_t a, int32x2_t b)
+        ///   LSX: VSADD.WU Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x1_t vsadd_d(int64x1_t a, uint64x1_t b)
+        ///   LSX: VSADD.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<long> AddSaturate(Vector64<long> left, Vector64<ulong> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x1_t vsadd_du(uint64x1_t a, int64x1_t b)
+        ///   LSX: VSADD.DU Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<ulong> AddSaturate(Vector64<ulong> left, Vector64<long> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int8x16_t vsadd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x8_t vsadd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int32x4_t vsadd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int64x2_t vsadd_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint8x16_t vsadd_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSADD.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint16x8_t vsadd_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSADD.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsadd_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSADD.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsadd_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSADD.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right) => AddSaturate(left, right);
+
+        /// <summary>
+        /// int16x8_t vhaddw_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VHADDW.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x8_t vhaddw_hu_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VHADDW.HU.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AddOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x4_t vhaddw_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VHADDW.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x4_t vhaddw_wu_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VHADDW.WU.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> AddOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x2_t vhaddw_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VHADDW.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x2_t vhaddw_du_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VHADDW.DU.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x1_t vhaddw_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VHADDW.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x1_t vhaddw_qu_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VHADDW.QU.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => AddOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x8_t vaddwev_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWEV.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x8_t vaddwev_h_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADDWEV.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x4_t vaddwev_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWEV.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddEvenElementsWidening(Vector128<short> left, Vector128<short> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x4_t vaddwev_w_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADDWEV.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> AddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x2_t vaddwev_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWEV.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<int> left, Vector128<int> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x2_t vaddwev_d_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADDWEV.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x1_t vaddwev_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWEV.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<long> left, Vector128<long> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x1_t vaddwev_q_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADDWEV.Q.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x8_t vaddwod_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddOddElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x8_t vaddwod_h_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VADDWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AddOddElementsWidening(Vector128<byte> left, Vector128<byte> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x4_t vaddwod_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWOD.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddOddElementsWidening(Vector128<short> left, Vector128<short> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x4_t vaddwod_w_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VADDWOD.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> AddOddElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x2_t vaddwod_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWOD.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<int> left, Vector128<int> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x2_t vaddwod_d_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VADDWOD.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<uint> left, Vector128<uint> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x1_t vaddwod_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWOD.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<long> left, Vector128<long> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x1_t vaddwod_q_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VADDWOD.Q.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddOddElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x8_t vaddwev_h_bu_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWEV.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddEvenElementsWidening(Vector128<byte> left, Vector128<sbyte> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x4_t vaddwev_w_hu_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWEV.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddEvenElementsWidening(Vector128<ushort> left, Vector128<short> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x2_t vaddwev_d_wu_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWEV.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<uint> left, Vector128<int> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x1_t vaddwev_q_du_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWEV.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddEvenElementsWidening(Vector128<ulong> left, Vector128<long> right) => AddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int16x8_t vaddwod_h_bu_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VADDWOD.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AddOddElementsWidening(Vector128<byte> left, Vector128<sbyte> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x4_t vaddwod_w_hu_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VADDWOD.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> AddOddElementsWidening(Vector128<ushort> left, Vector128<short> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x2_t vaddwod_d_wu_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VADDWOD.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<uint> left, Vector128<int> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x1_t vaddwod_q_du_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VADDWOD.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddOddElementsWidening(Vector128<ulong> left, Vector128<long> right) => AddOddElementsWidening(left, right);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<sbyte> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.HU.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector128<byte> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<short> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.WU.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector128<ushort> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<int> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.DU.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<uint> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AddHorizontalElements(Vector128<long> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: VHADDW.QU.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AddHorizontalElements(Vector128<ulong> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_float_elements witin vector.
+        /// </summary>
+        public static Vector64<float> AddHorizontalElements(Vector128<float> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        ///   NOTE: this is implemented by multi instructions.
+        ///   LSX: sum_all_double_elements witin vector.
+        /// </summary>
+        public static Vector64<double> AddHorizontalElements(Vector128<double> value) => AddHorizontalElements(value);
+
+        /// <summary>
+        /// int8x8_t vsub_b(int8x8_t a, int8x8_t b)
+        ///   LSX: VSUB.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<sbyte> Subtract(Vector64<sbyte> left, Vector64<sbyte> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint8x8_t vsub_b(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VSUB.B Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<byte> Subtract(Vector64<byte> left, Vector64<byte> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int16x4_t vsub_h(int16x4_t a, int16x4_t b)
+        ///   LSX: VSUB.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<short> Subtract(Vector64<short> left, Vector64<short> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint16x4_t vsub_h(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VSUB.H Vd.4H, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector64<ushort> Subtract(Vector64<ushort> left, Vector64<ushort> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int32x2_t vsub_w(int32x2_t a, int32x2_t b)
+        ///   LSX: VSUB.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<int> Subtract(Vector64<int> left, Vector64<int> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint32x2_t vsub_w(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VSUB.W Vd.2W, Vj.2W, Vk.2W
+        /// </summary>
+        public static Vector64<uint> Subtract(Vector64<uint> left, Vector64<uint> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int64x1_t vsub_d(int64x1_t a, int64x1_t b)
+        ///   LSX: VSUB.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<long> Subtract(Vector64<long> left, Vector64<long> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint64x1_t vsub_d(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VSUB.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<ulong> Subtract(Vector64<ulong> left, Vector64<ulong> right) => Subtract(left, right);
+
+        /// <summary>
+        /// float32x2_t vfsub_s(float32x2_t a, float32x2_t b)
+        ///   LSX: VFSUB.S Vd.2S, Vj.2S, Vk.2S
+        /// </summary>
+        public static Vector64<float> Subtract(Vector64<float> left, Vector64<float> right) => Subtract(left, right);
+
+        /// <summary>
+        /// float64x1_t vfsub_d(float64x1_t a, float64x1_t b)
+        ///   LSX: VFSUB.D Vd.D, Vj.D, Vk.D
+        /// </summary>
+        public static Vector64<double> Subtract(Vector64<double> left, Vector64<double> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int8x16_t vsub_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint8x16_t vsub_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int16x8_t vsub_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint16x8_t vsub_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int32x4_t vsub_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsub_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int64x2_t vsub_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right) => Subtract(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsub_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right) => Subtract(left, right);
+
+        /// <summary>
+        /// float32x4_t vfsub_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFSUB.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right) => Subtract(left, right);
+
+        /// <summary>
+        /// float64x2_t vfsub_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right) => Subtract(left, right);
+
+        /// <summary>
+        /// int16x8_t vhsubw_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VHSUBW.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> SubtractOddEvenElementsWidening(Vector128<sbyte> left, Vector128<sbyte> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint16x8_t vhsubw_hu_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VHSUBW.HU.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> SubtractOddEvenElementsWidening(Vector128<byte> left, Vector128<byte> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int32x4_t vhsubw_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VHSUBW.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> SubtractOddEvenElementsWidening(Vector128<short> left, Vector128<short> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint32x4_t vhsubw_wu_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VHSUBW.WU.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> SubtractOddEvenElementsWidening(Vector128<ushort> left, Vector128<ushort> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int64x2_t vhsubw_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VHSUBW.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> SubtractOddEvenElementsWidening(Vector128<int> left, Vector128<int> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint64x2_t vhsubw_du_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VHSUBW.DU.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> SubtractOddEvenElementsWidening(Vector128<uint> left, Vector128<uint> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int128x1_t vhsubw_q_d(int64x2_t a, int64x2_t b)  TODO: long --> longlong 128bits.
+        ///   LSX: VHSUBW.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> SubtractOddEvenElementsWidening(Vector128<long> left, Vector128<long> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// uint128x1_t vhsubw_qu_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VHSUBW.QU.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> SubtractOddEvenElementsWidening(Vector128<ulong> left, Vector128<ulong> right) => SubtractOddEvenElementsWidening(left, right);
+
+        /// <summary>
+        /// int8x16_t vssub_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint8x16_t vssub_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSSUB.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int16x8_t vssub_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint16x8_t vssub_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSSUB.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int32x4_t vssub_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint32x4_t vssub_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSSUB.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int64x2_t vssub_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> SubtractSaturate(Vector128<long> left, Vector128<long> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// uint64x2_t vssub_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSSUB.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> SubtractSaturate(Vector128<ulong> left, Vector128<ulong> right) => SubtractSaturate(left, right);
+
+        /// <summary>
+        /// int8x16_t vmul_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint8x16_t vmul_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int16x8_t vmul_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmul_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int32x4_t vmul_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmul(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int64x2_t vmul_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Multiply(Vector128<long> left, Vector128<long> right) => Multiply(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmul(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right) => Multiply(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmul_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMUL.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right) => Multiply(left, right);
+
+        /// <summary>
+        /// float64x2_t vfmul_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMUL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right) => Multiply(left, right);
+
+        /// <summary>
+        /// int8x16_t vmuh_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMUH.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> MultiplyHight(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint8x16_t vmuh_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMUH.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> MultiplyHight(Vector128<byte> left, Vector128<byte> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int16x8_t vmuh_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMUH.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> MultiplyHight(Vector128<short> left, Vector128<short> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmuh_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMUH.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> MultiplyHight(Vector128<ushort> left, Vector128<ushort> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int32x4_t vmuh_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMUL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> MultiplyHight(Vector128<int> left, Vector128<int> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmuh_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMUH.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> MultiplyHight(Vector128<uint> left, Vector128<uint> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int64x2_t vmuh_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMUH.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyHight(Vector128<long> left, Vector128<long> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmuh_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMUH.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplyHight(Vector128<ulong> left, Vector128<ulong> right) => MultiplyHight(left, right);
+
+        /// <summary>
+        /// int8x16_t vdiv_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VDIV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Divide(Vector128<sbyte> left, Vector128<sbyte> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint8x16_t vdiv_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VDIV.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Divide(Vector128<byte> left, Vector128<byte> right) => Divide(left, right);
+
+        /// <summary>
+        /// int16x8_t vdiv_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VDIV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Divide(Vector128<short> left, Vector128<short> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint16x8_t vdiv_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VDIV.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Divide(Vector128<ushort> left, Vector128<ushort> right) => Divide(left, right);
+
+        /// <summary>
+        /// int32x4_t vdiv_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VDIV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Divide(Vector128<int> left, Vector128<int> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint32x4_t vdiv_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VDIV.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Divide(Vector128<uint> left, Vector128<uint> right) => Divide(left, right);
+
+        /// <summary>
+        /// int64x2_t vdiv_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Divide(Vector128<long> left, Vector128<long> right) => Divide(left, right);
+
+        /// <summary>
+        /// uint64x2_t vdiv_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VDIV.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Divide(Vector128<ulong> left, Vector128<ulong> right) => Divide(left, right);
+
+        /// <summary>
+        /// float32x4_t vfdiv_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFDIV.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right) => Divide(left, right);
+
+        /// <summary>
+        /// float64x2_t vfdiv_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFDIV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right) => Divide(left, right);
+
+        /// <summary>
+        /// int8x16_t vmod_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Modulo(Vector128<sbyte> left, Vector128<sbyte> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint8x16_t vmod_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMOD.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Modulo(Vector128<byte> left, Vector128<byte> right) => Modulo(left, right);
+
+        /// <summary>
+        /// int16x8_t vmod_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Modulo(Vector128<short> left, Vector128<short> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmod_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMOD.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Modulo(Vector128<ushort> left, Vector128<ushort> right) => Modulo(left, right);
+
+        /// <summary>
+        /// int32x4_t vmod_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Modulo(Vector128<int> left, Vector128<int> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmod_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMOD.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Modulo(Vector128<uint> left, Vector128<uint> right) => Modulo(left, right);
+
+        /// <summary>
+        /// int64x2_t vmod_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Modulo(Vector128<long> left, Vector128<long> right) => Modulo(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmod_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMOD.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Modulo(Vector128<ulong> left, Vector128<ulong> right) => Modulo(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmadd_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMADD.S Vd.4S, Vj.4S, Vk.4S, Va.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplyAdd(Vector128<float> left, Vector128<float> right, Vector128<float> addend) => FusedMultiplyAdd(left, right, addend);
+
+        /// <summary>
+        /// float64x2_t vfmadd_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMADD.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplyAdd(Vector128<double> left, Vector128<double> right, Vector128<double> addend) => FusedMultiplyAdd(left, right, addend);
+
+        /// <summary>
+        /// float32x4_t vfnmadd_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFNMADD.S Vd.4S, Vj.4S, Vk.4S, Va.4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplyAddNegated(Vector128<float> left, Vector128<float> right, Vector128<float> addend) => FusedMultiplyAddNegated(left, right, addend);
+
+        /// <summary>
+        /// float64x2_t vfnmadd_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFNMADD.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplyAddNegated(Vector128<double> left, Vector128<double> right, Vector128<double> addend) => FusedMultiplyAddNegated(left, right, addend);
+
+        /// <summary>
+        /// int8x16_t vmadd_b(int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B               //NOTE: The Vd is both input and output while input as addend.
+        /// </summary>
+        public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint8x16_t vmadd_b(uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VMADD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int16x8_t vmadd_h(int16x8_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint16x8_t vmadd_h(uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMADD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int32x4_t vmadd_w(int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x4_t vmadd_w(uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMADD.W  Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyAdd(addend, left, right);
+
+        /// <summary>
+        /// int64x2_t vmadd_d(int64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyAdd(Vector128<long> minuend, Vector128<long> left, Vector128<long> right) => MultiplyAdd(minuend, left, right);
+
+        /// <summary>
+        /// uint64x2_t vmadd_d(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VMADD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplyAdd(Vector128<ulong> minuend, Vector128<ulong> left, Vector128<ulong> right) => MultiplyAdd(minuend, left, right);
+
+        /// <summary>
+        /// float32x4_t vfmsub_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFMSUB.S Vd.4S, Vj.4S, Vk.4S, Va,4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplySubtract(Vector128<float> left, Vector128<float> right, Vector128<float> minuend) => FusedMultiplySubtract(left, right, minuend);
+
+        /// <summary>
+        /// float64x2_t vfmsub_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFMSUB.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplySubtract(Vector128<double> left, Vector128<double> right, Vector128<double> minuend) => FusedMultiplySubtract(left, right, minuend);
+
+        /// <summary>
+        /// float32x4_t vfnmsub_s(float32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VFNMSUB.S Vd.4S, Vj.4S, Vk.4S, Va,4S
+        /// </summary>
+        public static Vector128<float> FusedMultiplySubtractNegated(Vector128<float> left, Vector128<float> right, Vector128<float> minuend) => FusedMultiplySubtractNegated(left, right, minuend);
+
+        /// <summary>
+        /// float64x2_t vfnmsub_d(float64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VFNMSUB.D Vd.2D, Vj.2D, Vk.2D, Va.2D
+        /// </summary>
+        public static Vector128<double> FusedMultiplySubtractNegated(Vector128<double> left, Vector128<double> right, Vector128<double> minuend) => FusedMultiplySubtractNegated(left, right, minuend);
+
+        /// <summary>
+        /// int8x16_t vmsub_b(int8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B               //NOTE: The Vd is both input and output while input as minuend.
+        /// </summary>
+        public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint8x16_t vmsub_b(uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VMSUB.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> MultiplySubtract(Vector128<byte> minuend, Vector128<byte> left, Vector128<byte> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x8_t vmsub_h(int16x8_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> MultiplySubtract(Vector128<short> minuend, Vector128<short> left, Vector128<short> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint16x8_t vmsub_h(uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMSUB.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> MultiplySubtract(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int32x4_t vmsub_w(int32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint32x4_t vmsub_w(uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMSUB.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int64x2_t vmsub_d(int64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplySubtract(Vector128<long> minuend, Vector128<long> left, Vector128<long> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// uint64x2_t vmsub_d(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VMSUB.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplySubtract(Vector128<ulong> minuend, Vector128<ulong> left, Vector128<ulong> right) => MultiplySubtract(minuend, left, right);
+
+        /// <summary>
+        /// int16x8_t vmaddwev_h_b(int16x8_t a, int8x8_t b, int8x8_t c)
+        ///   LSX: VMADDWEV.H.B Vd.8H, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningLowerAndAdd(Vector128<short> addend, Vector64<sbyte> left, Vector64<sbyte> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint16x8_t vmaddwev_h_bu(uint16x8_t a, uint8x8_t b, uint8x8_t c)
+        ///   LSX: VMADDWEV.H.BU Vd.8H, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningLowerAndAdd(Vector128<ushort> addend, Vector64<byte> left, Vector64<byte> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int32x4_t vmaddwev_w_h(int32x4_t a, int16x4_t b, int16x4_t c)
+        ///   LSX: VMADDWEV.W.H Vd.4W, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x4_t vmaddwev_w_hu(uint32x4_t a, uint16x4_t b, uint16x4_t c)
+        ///   LSX: VMADDWEV.W.HU Vd.4W, Vj.4H, Vk.4H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int64x2_t vmaddwev_d_w(int64x2_t a, int32x2_t b, int32x2_t c)
+        ///   LSX: VMADDWEV.D.W Vd.2D, Vj.2S, Vk.2S
+        /// </summary>
+        public static Vector128<long> MultiplyWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint64x2_t vmaddwev_d_wu(uint64x2_t a, uint32x2_t b, uint32x2_t c)
+        ///   LSX: VMADDWEV.D.WU Vd.2D, Vj.2S, Vk.2S
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right) => MultiplyWideningLowerAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int16x8_t vmaddwod_h_b(int16x8_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VMADDWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningUpperAndAdd(Vector128<short> addend, Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint16x8_t vmaddwod_h_bu(uint16x8_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VMADDWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningUpperAndAdd(Vector128<ushort> addend, Vector128<byte> left, Vector128<byte> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int32x4_t vmaddwod_w_h(int32x4_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VMADDWOD.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint32x4_t vmaddwod_w_hu(uint32x4_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VMADDWOD.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// int64x2_t vmaddwod_d_w(int64x2_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VMADDWOD.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> MultiplyWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        /// uint64x2_t vmaddwod_d_wu(uint64x2_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VMADDWOD.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right) => MultiplyWideningUpperAndAdd(addend, left, right);
+
+        /// <summary>
+        ///  int8x16_t vmsknz_b(int8x16_t value)
+        ///   LSX: VMSKNZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareNotEqualZero(Vector128<sbyte> value) => CompareNotEqualZero(value);
+
+        /// <summary>
+        ///  uint8x16_t vmsknz_b(uint8x16_t value)
+        ///   LSX: VMSKNZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> CompareNotEqualZero(Vector128<byte> value) => CompareNotEqualZero(value);
+
+        /// <summary>
+        /// int8x16_t vseqi_b(int8x16_t a, int8_t si5)
+        ///   LSX: VSEQI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int16x8_t vseqi_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSEQI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> CompareEqual(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int32x4_t vseqi_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSEQI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int64x2_t vseqi_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSEQI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> CompareEqual(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareEqual(value, si5);
+
+        /// <summary>
+        /// int8x16_t vseq_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSEQ.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint8x16_t vseq_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSEQ.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int16x8_t vseq_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSEQ.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint16x8_t vseq_h(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSEQ.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int32x4_t vseq_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSEQ.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vseq_w(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSEQ.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int64x2_t vseq_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vseq_d(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int32x4_t vfcmp_ceq_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CEQ.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareEqual(Vector128<float> left, Vector128<float> right) => CompareEqual(left, right);
+
+        /// <summary>
+        /// int64x2_t vfcmp_ceq_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CEQ.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareEqual(Vector128<double> left, Vector128<double> right) => CompareEqual(left, right);
+
+        /// <summary>
+        ///  int8x16_t vmskltz_b(int8x16_t value)
+        ///   LSX: VMSKLTZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThanZero(Vector128<sbyte> value) => CompareLessThanZero(value);
+
+        /// <summary>
+        ///  int16x8_t vmskltz_h(int16x8_t value)
+        ///   LSX: VMSKLTZ.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> CompareLessThanZero(Vector128<short> value) => CompareLessThanZero(value);
+
+        /// <summary>
+        ///  int32x4_t vmskltz_w(int32x4_t value)
+        ///   LSX: VMSKLTZ.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> CompareLessThanZero(Vector128<int> value) => CompareLessThanZero(value);
+
+        /// <summary>
+        ///  int64x2_t vmskltz_d(int64x2_t value)
+        ///   LSX: VMSKLTZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThanZero(Vector128<long> value) => CompareLessThanZero(value);
+
+        /// <summary>
+        /// int8x16_t vslti_b(int8x16_t a, int8_t si5)
+        ///   LSX: VSLTI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// int16x8_t vslti_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSLTI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> CompareLessThan(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// int32x4_t vslti_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSLTI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// int64x2_t vslti_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSLTI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> CompareLessThan(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThan(value, si5);
+
+        /// <summary>
+        /// uint8x16_t vslt_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLT.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint8x16_t vslt_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLT.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint16x8_t vslt_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLT.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint16x8_t vslt_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLT.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x4_t vslt_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint32x4_t vslt_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vslt_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vslt_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLT.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// int32x4_t vfcmp_clt_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThan(Vector128<float> left, Vector128<float> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// int64x2_t vfcmp_clt_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThan(Vector128<double> left, Vector128<double> right) => CompareLessThan(left, right);
+
+        /// <summary>
+        /// int8x16_t vslei_b(int8x16_t a, int8_t si5)
+        ///   LSX: VSLEI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// int16x8_t vslei_h(int16x8_t a, int8_t si5)
+        ///   LSX: VSLEI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// int32x4_t vslei_w(int32x4_t a, int8_t si5)
+        ///   LSX: VSLEI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// int64x2_t vslei_d(int64x2_t a, int8_t si5)
+        ///   LSX: VSLEI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value, [ConstantExpected(Min = -16, Max = (byte)(15))] sbyte si5) => CompareLessThanOrEqual(value, si5);
+
+        /// <summary>
+        /// uint8x16_t vsle_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x8_t vsle_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsle_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsle_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x16_t vslei_bu(uint8x16_t a, uint8_t ui5)
+        ///   LSX: VSLEI.BU Vd.16B, Vj.16B, ui5
+        /// </summary>
+        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint16x8_t vslei_hu(uint16x8_t a, uint8_t ui5)
+        ///   LSX: VSLEI.HU Vd.8H, Vj.8H, ui5
+        /// </summary>
+        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint32x4_t vslei_wu(uint32x4_t a, uint8_t ui5)
+        ///   LSX: VSLEI.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint64x2_t vslei_du(uint64x2_t a, uint8_t ui5)
+        ///   LSX: VSLEI.DU Vd.2D, Vj.2D, ui5
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<long> value, [ConstantExpected(Max = (byte)(31))] byte ui5) => CompareLessThanOrEqual(value, ui5);
+
+        /// <summary>
+        /// uint8x16_t vsle_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x8_t vsle_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsle_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsle_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLE.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// int32x4_t vfcmp_cle_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// int64x2_t vfcmp_cle_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareLessThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x16_t vsle_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLE.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint16x8_t vsle_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLE.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsle_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLE.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsle_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint8x16_t vsle_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLE.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint16x8_t vsle_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLE.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint32x4_t vsle_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLE.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// uint64x2_t vsle_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLE.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// int32x4_t vfcmp_cle_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLE.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThan(Vector128<float> left, Vector128<float> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        /// int64x2_t vfcmp_cle_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLE.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThan(Vector128<double> left, Vector128<double> right) => CompareGreaterThan(left, right);
+
+        /// <summary>
+        ///  int8x16_t vmskgez_b(int8x16_t value)
+        ///   LSX: VMSKGEZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareGreaterThanOrEqualZero(Vector128<sbyte> value) => CompareGreaterThanOrEqualZero(value);
+
+        /// <summary>
+        /// uint8x16_t vslt_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLT.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint8x16_t vslt_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLT.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x8_t vslt_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VSLT.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint16x8_t vslt_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VSLT.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vslt_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VSLT.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint32x4_t vslt_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VSLT.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vslt_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VSLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// uint64x2_t vslt_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VSLT.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// int32x4_t vfcmp_clt_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFCMP.CLT.S Vd.4W, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<int> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// int64x2_t vfcmp_clt_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFCMP.CLT.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right) => CompareGreaterThanOrEqual(left, right);
+
+        /// <summary>
+        /// int8x16_t vmaxi_b(int8x16_t a, int8_t si5)
+        ///   LSX: VMAXI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> Max(Vector128<sbyte> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint8x16_t vmaxi_bu(uint8x16_t a, int8_t si5)
+        ///   LSX: VMAXI.BU Vd.16B, Vj.16B, ui5
+        /// </summary>
+        public static Vector128<byte> Max(Vector128<byte> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int16x8_t vmaxi_h(int16x8_t a, int8_t si5)
+        ///   LSX: VMAXI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> Max(Vector128<short> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint16x8_t vmaxi_hu(uint16x8_t a, int8_t si5)
+        ///   LSX: VMAXI.HU Vd.8H, Vj.8H, ui5
+        /// </summary>
+        public static Vector128<ushort> Max(Vector128<ushort> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int32x4_t vmaxi_w(int32x4_t a, int8_t si5)
+        ///   LSX: VMAXI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> Max(Vector128<int> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint32x4_t vmaxi_wu(uint32x4_t a, int8_t si5)
+        ///   LSX: VMAXI.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> Max(Vector128<uint> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int64x2_t vmaxi_d(int64x2_t a, int8_t si5)
+        ///   LSX: VMAXI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> Max(Vector128<long> value, const sbyte si5) => Max(value, si5);
+
+        /// <summary>
+        /// uint64x2_t vmaxi_du(uint64x2_t a, int8_t si5)
+        ///   LSX: VMAXI.DU Vd.2D, Vj.2D, ui5
+        /// </summary>
+        public static Vector128<ulong> Max(Vector128<ulong> value, const byte ui5) => Max(value, ui5);
+
+        /// <summary>
+        /// int8x16_t vmax_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMAX.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right) => Max(left, right);
+
+        /// <summary>
+        /// uint8x16_t vmax_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMAX.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right) => Max(left, right);
+
+        /// <summary>
+        /// int16x8_t vmax_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMAX.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Max(Vector128<short> left, Vector128<short> right) => Max(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmax_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMAX.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right) => Max(left, right);
+
+        /// <summary>
+        /// int32x4_t vmax_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMAX.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Max(Vector128<int> left, Vector128<int> right) => Max(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmax_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMAX.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right) => Max(left, right);
+
+        /// <summary>
+        /// int64x2_t vmax_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMAX.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Max(Vector128<long> left, Vector128<long> right) => Max(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmax_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMAX.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Max(Vector128<ulong> left, Vector128<ulong> right) => Max(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmax_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMAX.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Max(Vector128<float> left, Vector128<float> right) => Max(left, right);
+
+        /// <summary>
+        /// float64x2_t vfmax_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMAX.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Max(Vector128<double> left, Vector128<double> right) => Max(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmaxa_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMAXA.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> MaxFloatAbsolute(Vector128<float> left, Vector128<float> right) => MaxFloatAbsolute(left, right);
+
+        /// <summary>
+        /// float64x2_t vfmaxa_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMAXA.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> MaxFloatAbsolute(Vector128<double> left, Vector128<double> right) => MaxFloatAbsolute(left, right);
+
+        /// <summary>
+        /// int8x16_t vmini_b(int8x16_t a, int8_t si5)
+        ///   LSX: VMINI.B Vd.16B, Vj.16B, si5
+        /// </summary>
+        public static Vector128<sbyte> Min(Vector128<sbyte> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint8x16_t vmini_bu(uint8x16_t a, int8_t si5)
+        ///   LSX: VMINI.BU Vd.16B, Vj.16B, ui5
+        /// </summary>
+        public static Vector128<byte> Min(Vector128<byte> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int16x8_t vmini_h(int16x8_t a, int8_t si5)
+        ///   LSX: VMINI.H Vd.8H, Vj.8H, si5
+        /// </summary>
+        public static Vector128<short> Min(Vector128<short> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint16x8_t vmini_hu(uint16x8_t a, int8_t si5)
+        ///   LSX: VMINI.HU Vd.8H, Vj.8H, ui5
+        /// </summary>
+        public static Vector128<ushort> Min(Vector128<ushort> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int32x4_t vmini_w(int32x4_t a, int8_t si5)
+        ///   LSX: VMINI.W Vd.4W, Vj.4W, si5
+        /// </summary>
+        public static Vector128<int> Min(Vector128<int> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint32x4_t vmini_wu(uint32x4_t a, int8_t si5)
+        ///   LSX: VMINI.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> Min(Vector128<uint> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int64x2_t vmini_d(int64x2_t a, int8_t si5)
+        ///   LSX: VMINI.D Vd.2D, Vj.2D, si5
+        /// </summary>
+        public static Vector128<long> Min(Vector128<long> value, const sbyte si5) => Min(value, si5);
+
+        /// <summary>
+        /// uint64x2_t vmini_du(uint64x2_t a, int8_t si5)
+        ///   LSX: VMINI.DU Vd.2D, Vj.2D, ui5
+        /// </summary>
+        public static Vector128<ulong> Min(Vector128<ulong> value, const byte ui5) => Min(value, ui5);
+
+        /// <summary>
+        /// int8x16_t vmin_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMIN.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right) => Min(left, right);
+
+        /// <summary>
+        /// uint8x16_t vmin_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMIN.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right) => Min(left, right);
+
+        /// <summary>
+        /// int16x8_t vmin_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMIN.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Min(Vector128<short> left, Vector128<short> right) => Min(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmin_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMIN.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right) => Min(left, right);
+
+        /// <summary>
+        /// int32x4_t vmin_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMIN.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Min(Vector128<int> left, Vector128<int> right) => Min(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmin_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMIN.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right) => Min(left, right);
+
+        /// <summary>
+        /// int64x2_t vmin_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMIN.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Min(Vector128<long> left, Vector128<long> right) => Min(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmin_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMIN.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Min(Vector128<ulong> left, Vector128<ulong> right) => Min(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmin_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMIN.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> Min(Vector128<float> left, Vector128<float> right) => Min(left, right);
+
+        /// <summary>
+        /// float64x2_t vfmin_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMIN.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> Min(Vector128<double> left, Vector128<double> right) => Min(left, right);
+
+        /// <summary>
+        /// float32x4_t vfmina_s(float32x4_t a, float32x4_t b)
+        ///   LSX: VFMINA.S Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> MinFloatAbsolute(Vector128<float> left, Vector128<float> right) => MinFloatAbsolute(left, right);
+
+        /// <summary>
+        /// float64x2_t vfmina_d(float64x2_t a, float64x2_t b)
+        ///   LSX: VFMINA.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> MinFloatAbsolute(Vector128<double> left, Vector128<double> right) => MinFloatAbsolute(left, right);
+
+        /// <summary>
+        /// int8x16_t vbitsel_v(uint8x16_t a, int8x16_t b, int8x16_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> BitwiseSelect(Vector128<sbyte> select, Vector128<sbyte> left, Vector128<sbyte> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint8x16_t vbitsel_v(uint8x16_t a, uint8x16_t b, uint8x16_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> BitwiseSelect(Vector128<byte> select, Vector128<byte> left, Vector128<byte> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int16x8_t vbitsel_v(uint16x8_t a, int16x8_t b, int16x8_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> BitwiseSelect(Vector128<short> select, Vector128<short> left, Vector128<short> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint16x8_t vbitsel_v(uint16x8_t a, uint16x8_t b, uint16x8_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> BitwiseSelect(Vector128<ushort> select, Vector128<ushort> left, Vector128<ushort> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int32x4_t vbitsel_v(uint32x4_t a, int32x4_t b, int32x4_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> BitwiseSelect(Vector128<int> select, Vector128<int> left, Vector128<int> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint32x4_t vbitsel_v(uint32x4_t a, uint32x4_t b, uint32x4_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> BitwiseSelect(Vector128<uint> select, Vector128<uint> left, Vector128<uint> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int64x2_t vbitsel_v(uint64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> BitwiseSelect(Vector128<long> select, Vector128<long> left, Vector128<long> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// uint64x2_t vbitsel_v(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> BitwiseSelect(Vector128<ulong> select, Vector128<ulong> left, Vector128<ulong> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// float32x4_t vbitsel_v(uint32x4_t a, float32x4_t b, float32x4_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> BitwiseSelect(Vector128<float> select, Vector128<float> left, Vector128<float> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// float64x2_t vbitsel_v(uint64x2_t a, float64x2_t b, float64x2_t c)
+        ///   LSX: VBITSEL.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> BitwiseSelect(Vector128<double> select, Vector128<double> left, Vector128<double> right) => BitwiseSelect(select, left, right);
+
+        /// <summary>
+        /// int8x16_t vabsd_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VABSD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AbsoluteDifference(Vector128<sbyte> left, Vector128<sbyte> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint8x16_t vabsd_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VABSD.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AbsoluteDifference(Vector128<byte> left, Vector128<byte> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int16x8_t vabsd_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VABSD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AbsoluteDifference(Vector128<short> left, Vector128<short> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint16x8_t vabsd_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VABSD.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AbsoluteDifference(Vector128<ushort> left, Vector128<ushort> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int32x4_t vabsd_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VABSD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint32x4_t vabsd_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VABSD.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int64x2_t vabsd_d(uint64x2_t a, int64x2_t b, int64x2_t c)
+        ///   LSX: VABSD.D Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AbsoluteDifference(Vector128<long> left, Vector128<long> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// uint64x2_t vabsd_du(uint64x2_t a, uint64x2_t b, uint64x2_t c)
+        ///   LSX: VABSD.DU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AbsoluteDifference(Vector128<ulong> left, Vector128<ulong> right) => AbsoluteDifference(left, right);
+
+        ///// <summary>
+        ///// float32x4_t TODO(float32x4_t a, float32x4_t b)   multi-instructions.
+        /////   LSX: TODO Vd.4S, Vj.4S, Vk.4S
+        ///// </summary>
+        //public static Vector128<float> AbsoluteDifference(Vector128<float> left, Vector128<float> right) => AbsoluteDifference(left, right);
+
+        ///// <summary>
+        ///// float64x2_t TODO(float64x2_t a, float64x2_t b)
+        /////   LSX: TODO Vd.2D, Vj.2D, Vk.2D
+        ///// </summary>
+        //public static Vector128<double> AbsoluteDifference(Vector128<double> left, Vector128<double> right) => AbsoluteDifference(left, right);
+
+        /// <summary>
+        /// int8x16_t vld(int8_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// uint8x16_t vld(uint8_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// int16x8_t vld(int16_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// uint16x8_t vld(uint16_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// int32x4_t vld(int32_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// uint32x4_t vld(uint32_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// int64x2_t vld(int64_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// uint64x2_t vld(uint64_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// float32x4_t vld(float32_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// float64x2_t vld(float64_t const * ptr, const short si12)
+        ///   LSX: VLD Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadVector128(address, si12);
+
+        /// <summary>
+        /// int8x16_t vldx(int8_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.16B, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadVector128(sbyte* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// uint8x16_t vldx(uint8_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.16B, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<byte> LoadVector128(byte* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// int16x8_t vldx(int16_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.8H, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<short> LoadVector128(short* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// uint16x8_t vldx(uint16_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.8H, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadVector128(ushort* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// int32x4_t vldx(int32_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.4W, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<int> LoadVector128(int* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// uint32x4_t vldx(uint32_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.4W, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<uint> LoadVector128(uint* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// int64x2_t vldx(int64_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.2D, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<long> LoadVector128(long* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// uint64x2_t vldx(uint64_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.2D, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadVector128(ulong* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// float32x4_t vldx(float32_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.4S, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<float> LoadVector128(float* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// float64x2_t vldx(float64_t const * ptr, long offsetValue)
+        ///   LSX: VLDX Vd.2D, Rj, rk
+        /// </summary>
+        public static unsafe Vector128<double> LoadVector128(double* address, long offsetValue) => LoadVector128(address, offsetValue);
+
+        /// <summary>
+        /// int8x16_t vldrepl_b(int8_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.B Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<sbyte> LoadElementReplicateVector(sbyte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint8x16_t vldrepl_b(uint8_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.B Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe Vector128<byte> LoadElementReplicateVector(byte* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// int16x8_t vldrepl_h(int16_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.H Vd.8H, Rj, si11
+        /// </summary>
+        public static unsafe Vector128<short> LoadElementReplicateVector(short* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint16x8_t vldrepl_h(uint16_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.H Vd.8H, Rj, si11
+        /// </summary>
+        public static unsafe Vector128<ushort> LoadElementReplicateVector(ushort* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// int32x4_t vldrepl_w(int32_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.W Vd.4W, Rj, si10
+        /// </summary>
+        public static unsafe Vector128<int> LoadElementReplicateVector(int* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint32x4_t vldrepl_w(uint32_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.W Vd.4W, Rj, si10
+        /// </summary>
+        public static unsafe Vector128<uint> LoadElementReplicateVector(uint* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// int64x2_t vldrepl_d(int64_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.D Vd.2D, Rj, si9
+        /// </summary>
+        public static unsafe Vector128<long> LoadElementReplicateVector(long* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// uint64x2_t vldrepl_d(uint64_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.D Vd.2D, Rj, si9
+        /// </summary>
+        public static unsafe Vector128<ulong> LoadElementReplicateVector(ulong* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// float32x4_t vld(float32_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.W Vd.4S, Rj, si10
+        /// </summary>
+        public static unsafe Vector128<float> LoadElementReplicateVector(float* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// float64x2_t vldrepl_d(float64_t const * ptr, const short si12)
+        ///   LSX: VLDREPL.D Vd.2D, Rj, si9
+        /// </summary>
+        public static unsafe Vector128<double> LoadElementReplicateVector(double* address, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => LoadElementReplicateVector(address, si12);
+
+        /// <summary>
+        /// float32x4_t vfrecip_s(float32x4_t a)
+        ///   LSX: VFRECIP.S Vd.4S Vj.4S
+        /// </summary>
+        public static Vector128<float> Reciprocal(Vector128<float> value) => Reciprocal(value);
+
+        /// <summary>
+        /// float64x2_t vfrecip_d(float64x2_t a)
+        ///   LSX: VFRECIP.D Vd.2D Vj.2D
+        /// </summary>
+        public static Vector128<double> Reciprocal(Vector128<double> value) => Reciprocal(value);
+
+        /// <summary>
+        /// float32x4_t vfrsqrt_s(float32x4_t a)
+        ///   LSX: VFRSQRT.S Vd.4S Vj.4S
+        /// </summary>
+        public static Vector128<float> ReciprocalSqrt(Vector128<float> value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        /// float64x2_t vfrsqrt_d(float64x2_t a)
+        ///   LSX: VFRSQRT.D Vd.2D Vj.2D
+        /// </summary>
+        public static Vector128<double> ReciprocalSqrt(Vector128<double> value) => ReciprocalSqrt(value);
+
+        /// <summary>
+        /// float32x4_t vfsqrt_s(float32x4_t a)
+        ///   LSX: VFSQRT.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Sqrt(Vector128<float> value) => Sqrt(value);
+
+        /// <summary>
+        /// float64x2_t vfsqrt_d(float64x2_t a)
+        ///   LSX: VFSQRT.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Sqrt(Vector128<double> value) => Sqrt(value);
+
+        /// <summary>
+        /// float32x4_t vflogb_s(float32x4_t a)
+        ///   LSX: VFLOGB.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> FloatLogarithm2(Vector128<float> value) => FloatLogarithm2(value);
+
+        /// <summary>
+        /// float64x2_t vflogb_d(float64x2_t a)
+        ///   LSX: VFLOGB.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> FloatLogarithm2(Vector128<double> value) => FloatLogarithm2(value);
+
+        /// <summary>
+        /// void vst(int8x16_t val, int8_t* addr, const short si12)
+        ///   LSX: VST Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(uint8x16_t val, uint8_t* addr, const short si12)
+        ///   LSX: VST Vd.16B, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(int16x8_t val, int16_t* addr, const short si12)
+        ///   LSX: VST Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<short> vector, short* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(uint16x8_t val, uint16_t* addr, const short si12)
+        ///   LSX: VST Vd.8H, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(int32x4_t val, int32_t* addr, const short si12)
+        ///   LSX: VST Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<int> vector, int* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(uint32x4_t val, uint32_t* addr, const short si12)
+        ///   LSX: VST Vd.4W, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(int64x2_t val, int64_t* addr, const short si12)
+        ///   LSX: VST Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<long> vector, long* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(uint64x2_t val, uint64_t* addr, const short si12)
+        ///   LSX: VST Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(float32x4_t val, float32_t* addr, const short si12)
+        ///   LSX: VST Vd.4S, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<float> vector, float* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vst(float64x2_t val, float64_t* addr, const short si12)
+        ///   LSX: VST Vd.2D, Rj, si12
+        /// </summary>
+        public static unsafe void Store(Vector128<double> vector, double* addr, [ConstantExpected(Min = -2048, Max = 2047)] short si12) => Store(vector, addr, si12);
+
+        /// <summary>
+        /// void vstelm_b(int8x16_t val, int8_t* ptr, const short si8, const byte index)
+        ///   LSX: VSTELM.B Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<sbyte> vector, sbyte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(15))] byte idx) => StoreElement(vector, addr, si8, idx);
+
+        /// <summary>
+        /// void vstelm_b(uint8x16_t val, uint8_t* ptr, const short si8, const byte index)
+        ///   LSX: VSTELM.B Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<byte> vector, byte* addr, [ConstantExpected(Min = -128, Max = 127)] short si8, [ConstantExpected(Max = (byte)(15))] byte idx) => StoreElement(vector, addr, si8, idx);
+
+        /// <summary>
+        /// void vstelm_h(int16x8_t val, int16_t* ptr, const short si9, const byte index) // si9 is 2byte aligned.
+        ///   LSX: VSTELM.H Vd.8H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<short> vector, short* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(7))] byte idx) => StoreElement(vector, addr, si9, idx);
+
+        /// <summary>
+        /// void vstelm_h(uint16x8_t val, uint16_t* ptr, const short si9, const byte index)
+        ///   LSX: VSTELM.H Vd.8H, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<ushort> vector, ushort* addr, [ConstantExpected(Min = -256, Max = 254)] short si9, [ConstantExpected(Max = (byte)(7))] byte idx) => StoreElement(vector, addr, si9, idx);
+
+        /// <summary>
+        /// void vstelm_w(int32x4_t val, int* ptr, const short si10, const byte index) // si10 is 4byte aligned.
+        ///   LSX: VSTELM.W Vd.4W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<int> vector, int* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx) => StoreElement(vector, addr, si10, idx);
+
+        /// <summary>
+        /// void vstelm_w(uint32x4_t val, uint* ptr, const short si10, const byte index)
+        ///   LSX: VSTELM.W Vd.4W, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<uint> vector, uint* addr, [ConstantExpected(Min = -512, Max = 508)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx) => StoreElement(vector, addr, si10, idx);
+
+        /// <summary>
+        /// void vstelm_d(int64x2_t val, int64_t* ptr, const short si11, const byte index) // si11 is 8byte aligned.
+        ///   LSX: VSTELM.D Vd.2D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<long> vector, long* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx) => StoreElement(vector, addr, si11, idx);
+
+        /// <summary>
+        /// void vstelm_d(uint64x2_t val, uint64_t* ptr, const short si11, const byte index)
+        ///   LSX: VSTELM.D Vd.2D, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<ulong> vector, ulong* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx) => StoreElement(vector, addr, si11, idx);
+
+        /// <summary>
+        /// void vstelm_w(float32x4_t val, float32_t* ptr, const short si10, const byte index)
+        ///   LSX: VSTELM.W Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<float> vector, float* addr, [ConstantExpected(Min = -512, Max = 511)] short si10, [ConstantExpected(Max = (byte)(3))] byte idx) => StoreElement(vector, addr, si10, idx);
+
+        /// <summary>
+        /// void vstelm_d(float64x2_t val, float64_t* ptr, const short si11, const byte index)
+        ///   LSX: VSTELM.D Vd.16B, Rj, si8, idx
+        /// </summary>
+        public static unsafe void StoreElement(Vector128<double> vector, double* addr, [ConstantExpected(Min = -1024, Max = 1016)] short si11, [ConstantExpected(Max = (byte)(1))] byte idx) => StoreElement(vector, addr, si11, idx);
+
+        /// <summary>
+        /// int8x16_t vneg_b(int8x16_t a)
+        ///   LSX: VNEG.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> Negate(Vector128<sbyte> value) => Negate(value);
+
+        /// <summary>
+        /// int16x8_t vneg_h(int16x8_t a)
+        ///   LSX: VNEG.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> Negate(Vector128<short> value) => Negate(value);
+
+        /// <summary>
+        /// int32x4_t vneg_w(int32x4_t a)
+        ///   LSX: VNEG.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> Negate(Vector128<int> value) => Negate(value);
+
+        /// <summary>
+        /// int64x2_t vneg_d(int64x2_t a)
+        ///   LSX: VNEG.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> Negate(Vector128<long> value) => Negate(value);
+
+        /// <summary>
+        /// float32x4_t vbitrevi_w(float32x4_t a)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, 31
+        /// </summary>
+        public static Vector128<float> Negate(Vector128<float> value) => Negate(value);
+
+        /// <summary>
+        /// float64x2_t vbitrevi_d(float64x2_t a)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, 63
+        /// </summary>
+        public static Vector128<double> Negate(Vector128<double> value) => Negate(value);
+
+        /// <summary>
+        /// float64x1_t fneg_d(float64x1_t a)
+        ///   LSX: FNEG.D Fd, Fj
+        /// </summary>
+        public static Vector64<double> NegateScalar(Vector64<double> value) => NegateScalar(value);
+
+        /// <summary>
+        /// float32_t fneg_s(float32_t a)
+        ///   LSX: FNEG.S Fd, Fj
+        /// </summary>
+        public static Vector64<float> NegateScalar(Vector64<float> value) => NegateScalar(value);
+
+        /// <summary>
+        /// int16x8_t vmulwod_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMULWOD.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningOdd(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int32x4_t vmulwod_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMULWOD.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningOdd(Vector128<short> left, Vector128<short> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int64x2_t vmulwod_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMULWOD.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> MultiplyWideningOdd(Vector128<int> left, Vector128<int> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int128x1_t vmulwod_q_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMULWOD.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyWideningOdd(Vector128<long> left, Vector128<long> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// int16x8_t vmulwev_h_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VMULWEV.H.B Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> MultiplyWideningEven(Vector128<sbyte> left, Vector128<sbyte> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int32x4_t vmulwev_w_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VMULWEV.W.H Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<int> MultiplyWideningEven(Vector128<short> left, Vector128<short> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int64x2_t vmulwev_d_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VMULWEV.D.W Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<long> MultiplyWideningEven(Vector128<int> left, Vector128<int> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// int128x1_t vmulwev_q_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VMULWEV.Q.D Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> MultiplyWideningEven(Vector128<long> left, Vector128<long> right) => MultiplyWideningEven(left, right);
+
+        /// <summary>
+        /// uint16x8_t vmulwod_hu_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VMULWOD.H.BU Vd.8H, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> MultiplyWideningOdd(Vector128<byte> left, Vector128<byte> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint32x4_t vmulwod_wu_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VMULWOD.W.HU Vd.4W, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<uint> MultiplyWideningOdd(Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint64x2_t vmulwod_du_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VMULWOD.D.WU Vd.2D, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningOdd(Vector128<uint> left, Vector128<uint> right) => MultiplyWideningOdd(left, right);
+
+        /// <summary>
+        /// uint128x1_t vmulwod_qu_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VMULWOD.Q.DU Vd.Q, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> MultiplyWideningOdd(Vector128<ulong> left, Vector128<ulong> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// uint16x8_t vmulwev_hu_bu(uint8x16_t a, uint8x16_t b)
+        // ///   LSX: VMULWEV.H.BU Vd.8H, Vj.16B, Vk.16B
+        // /// </summary>
+        // public static Vector128<ushort> MultiplyWideningEven(Vector128<byte> left, Vector128<byte> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// uint32x4_t vmulwev_wu_hu(uint16x8_t a, uint16x8_t b)
+        // ///   LSX: VMULWEV.W.HU Vd.4W, Vj.8H, Vk.8H
+        // /// </summary>
+        // public static Vector128<uint> MultiplyWideningEven(Vector128<ushort> left, Vector128<ushort> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// uint64x2_t vmulwev_du_wu(uint32x4_t a, uint32x4_t b)
+        // ///   LSX: VMULWEV.D.WU Vd.2D, Vj.4W, Vk.4W
+        // /// </summary>
+        // public static Vector128<ulong> MultiplyWideningEven(Vector128<uint> left, Vector128<uint> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// uint128x1_t vmulwev_qu_du(uint64x2_t a, uint64x2_t b)
+        // ///   LSX: VMULWEV.Q.DU Vd.Q, Vj.2D, Vk.2D
+        // /// </summary>
+        // public static Vector128<ulong> MultiplyWideningEven(Vector128<ulong> left, Vector128<ulong> right) => MultiplyWideningEven(left, right);
+
+        // /// <summary>
+        // /// int16x8_t vmulwod_h_bu(uint8x16_t a, int8x16_t b)
+        // ///   LSX: VMULWOD.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        // /// </summary>
+        // public static Vector128<short> MultiplyWideningOdd(Vector128<byte> left, Vector128<sbyte> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int32x4_t vmulwod_w_hu(uint16x8_t a, int16x8_t b)
+        // ///   LSX: VMULWOD.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        // /// </summary>
+        // public static Vector128<int> MultiplyWideningOdd(Vector128<ushort> left, Vector128<short> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int64x2_t vmulwod_d_wu(uint32x4_t a, int32x4_t b)
+        // ///   LSX: VMULWOD.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningOdd(Vector128<uint> left, Vector128<int> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int128x1_t vmulwod_q_du(uint64x2_t a, int64x2_t b)
+        // ///   LSX: VMULWOD.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningOdd(Vector128<ulong> left, Vector128<long> right) => MultiplyWideningOdd(left, right);
+
+        // /// <summary>
+        // /// int16x8_t vmulwev_h_bu(uint8x16_t a, int8x16_t b)
+        // ///   LSX: VMULWEV.H.BU.B Vd.8H, Vj.16B, Vk.16B
+        // /// </summary>
+        // public static Vector128<short> MultiplyWideningEven(Vector128<byte> unsign, Vector128<sbyte> sign) => MultiplyWideningEven(unsign, sign);
+
+        // /// <summary>
+        // /// int32x4_t vmulwev_w_hu(uint16x8_t a, int16x8_t b)
+        // ///   LSX: VMULWEV.W.HU.H Vd.4W, Vj.8H, Vk.8H
+        // /// </summary>
+        // public static Vector128<int> MultiplyWideningEven(Vector128<ushort> unsign, Vector128<short> sign) => MultiplyWideningEven(unsign, sign);
+
+        // /// <summary>
+        // /// int64x2_t vmulwev_d_wu(uint32x4_t a, int32x4_t b)
+        // ///   LSX: VMULWEV.D.WU.W Vd.2D, Vj.4W, Vk.4W
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningEven(Vector128<uint> unsign, Vector128<int> sign) => MultiplyWideningEven(unsign, sign);
+
+        // /// <summary>
+        // /// int128x1_t vmulwev_q_du(uint64x2_t a, int64x2_t b)
+        // ///   LSX: VMULWEV.Q.DU.D Vd.Q, Vj.2D, Vk.2D
+        // /// </summary>
+        // public static Vector128<long> MultiplyWideningEven(Vector128<ulong> unsign, Vector128<long> sign) => MultiplyWideningEven(unsign, sign);
+
+        /// <summary>
+        /// int8x16_t vavg_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VAVG.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Average(Vector128<sbyte> left, Vector128<sbyte> right) => Average(left, right);
+
+        /// <summary>
+        /// uint8x16_t vavg_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VAVG.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right) => Average(left, right);
+
+        /// <summary>
+        /// int16x8_t vavg_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VAVG.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> Average(Vector128<short> left, Vector128<short> right) => Average(left, right);
+
+        /// <summary>
+        /// uint16x8_t vavg_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VAVG.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right) => Average(left, right);
+
+        /// <summary>
+        /// int32x4_t vavg_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VAVG.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> Average(Vector128<int> left, Vector128<int> right) => Average(left, right);
+
+        /// <summary>
+        /// uint32x4_t vavg_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAVG.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> Average(Vector128<uint> left, Vector128<uint> right) => Average(left, right);
+
+        /// <summary>
+        /// int64x2_t vavg_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VAVG.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> Average(Vector128<long> left, Vector128<long> right) => Average(left, right);
+
+        /// <summary>
+        /// uint64x2_t vavg_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VAVG.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> Average(Vector128<ulong> left, Vector128<ulong> right) => Average(left, right);
+
+        /// <summary>
+        /// int8x16_t vavgr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VAVGR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> AverageRounded(Vector128<sbyte> left, Vector128<sbyte> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint8x16_t vavgr_bu(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VAVGR.BU Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AverageRounded(Vector128<byte> left, Vector128<byte> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int16x8_t vavgr_h(int16x8_t a, int16x8_t b)
+        ///   LSX: VAVGR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> AverageRounded(Vector128<short> left, Vector128<short> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint16x8_t vavgr_hu(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VAVGR.HU Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> AverageRounded(Vector128<ushort> left, Vector128<ushort> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int32x4_t vavgr_w(int32x4_t a, int32x4_t b)
+        ///   LSX: VAVGR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> AverageRounded(Vector128<int> left, Vector128<int> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint32x4_t vavgr_wu(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAVGR.WU Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> AverageRounded(Vector128<uint> left, Vector128<uint> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int64x2_t vavgr_d(int64x2_t a, int64x2_t b)
+        ///   LSX: VAVGR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> AverageRounded(Vector128<long> left, Vector128<long> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// uint64x2_t vavgr_du(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VAVGR.DU Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> AverageRounded(Vector128<ulong> left, Vector128<ulong> right) => AverageRounded(left, right);
+
+        /// <summary>
+        /// int16x8_t vsllwil_h_b(int8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.H.B Vd.8H, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<short> SignExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift) => SignExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsllwil_w_h(int16x4_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.W.H Vd.4W, Vj.4H, ui4
+        /// </summary>
+        public static Vector128<int> SignExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift) => SignExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsllwil_d_w(int32x2_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.D.W Vd.2D, Vj.2W, ui5
+        /// </summary>
+        public static Vector128<long> SignExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift) => SignExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsllwil_hu_bu(uint8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.HU.BU Vd.8H, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningLowerAndShiftLeft(Vector64<byte> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsllwil_hu_bu(int8x16_t a, uint8_t ui3)
+        ///   LSX: VSLLWIL.HU.BU Vd.8H, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<short> ZeroExtendWideningLowerAndShiftLeft(Vector64<sbyte> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsllwil_wu_hu(uint16x8_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.WU.HU Vd.4W, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningLowerAndShiftLeft(Vector64<ushort> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsllwil_wu_hu(int16x8_t a, uint8_t ui4)
+        ///   LSX: VSLLWIL.WU.HU Vd.4W, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningLowerAndShiftLeft(Vector64<short> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsllwil_du_wu(uint32x4_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.DU.WU Vd.2D, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLowerAndShiftLeft(Vector64<uint> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsllwil_du_wu(int32x4_t a, uint8_t ui5)
+        ///   LSX: VSLLWIL.DU.WU Vd.2D, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningLowerAndShiftLeft(Vector64<int> value, byte shift) => ZeroExtendWideningLowerAndShiftLeft(value, shift);
+
+        /// <summary>
+        /// uint128x1_t vextl_qu_du(int64_t a)
+        ///   LSX: VEXTL.QU.DU Vd.Q, Vj.D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<long> value) => ZeroExtendWideningLower(value);
+
+        /// <summary>
+        /// uint128x1_t vextl_qu_du(uint64_t a)
+        ///   LSX: VEXTL.QU.DU Vd.Q, Vj.D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningLower(Vector64<ulong> value) => ZeroExtendWideningLower(value);
+
+        /// <summary>
+        /// int16x8_t vexth_h_b(int8x16_t a)
+        ///   LSX: VEXTH.H.B Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> SignExtendWideningUpper(Vector128<sbyte> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int32x4_t vexth_w_h(int16x8_t a)
+        ///   LSX: VEXTH.W.H Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> SignExtendWideningUpper(Vector128<short> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int64x2_t vexth_d_w(int32x4_t a)
+        ///   LSX: VEXTH.D.W Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> SignExtendWideningUpper(Vector128<int> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int128x1_t vexth_d_w(int64x2_t a)
+        ///   LSX: VEXTH.Q.D Vd.Q, Vj.2D
+        /// </summary>
+        public static Vector128<long> SignExtendWideningUpper(Vector128<long> value) => SignExtendWideningUpper(value);
+
+        /// <summary>
+        /// int16x8_t vexth_HU_BU(int8x16_t a)
+        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<short> ZeroExtendWideningUpper(Vector128<sbyte> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint16x8_t vexth_HU_BU(uint8x16_t a)
+        ///   LSX: VEXTH.HU.BU Vd.8H, Vj.16B
+        /// </summary>
+        public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// int32x4_t vexth_WU_HU(int16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint32x4_t vexth_WU_HU(uint16x8_t a)
+        ///   LSX: VEXTH.WU.HU Vd.4W, Vj.8H
+        /// </summary>
+        public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// int64x2_t vexth_DU_WU(uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint64x2_t vexth_DU_WU(uint32x4_t a)
+        ///   LSX: VEXTH.DU.WU Vd.2D, Vj.4W
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// int128x1_t vexth_DU_WU(int64x2_t a)
+        ///   LSX: VEXTH.QU.DU Vd.Q, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<long> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// uint128x1_t vexth_DU_WU(uint64x2_t a)
+        ///   LSX: VEXTH.QU.DU Vd.Q, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<ulong> value) => ZeroExtendWideningUpper(value);
+
+        /// <summary>
+        /// int8x16_t vand_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right) => And(left, right);
+
+        /// <summary>
+        /// uint8x16_t vand_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right) => And(left, right);
+
+        /// <summary>
+        /// int16x8_t vand_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> And(Vector128<short> left, Vector128<short> right) => And(left, right);
+
+        /// <summary>
+        /// uint16x8_t vand_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right) => And(left, right);
+
+        /// <summary>
+        /// int32x4_t vand_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> And(Vector128<int> left, Vector128<int> right) => And(left, right);
+
+        /// <summary>
+        /// uint32x4_t vand_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right) => And(left, right);
+
+        /// <summary>
+        /// int64x2_t vand_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> And(Vector128<long> left, Vector128<long> right) => And(left, right);
+
+        /// <summary>
+        /// uint64x2_t vand_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right) => And(left, right);
+
+        /// <summary>
+        /// float32x4_t vand_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> And(Vector128<float> left, Vector128<float> right) => And(left, right);
+
+        /// <summary>
+        /// float64x2_t vand_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VAND.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> And(Vector128<double> left, Vector128<double> right) => And(left, right);
+
+        /// <summary>
+        /// int8x16_t vandn_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint8x16_t vandn_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int16x8_t vandn_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint16x8_t vandn_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int32x4_t vandn_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint32x4_t vandn_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right) => AndNot(left, right);
+
+        /// <summary>
+        /// int64x2_t vandn_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint64x2_t vandn_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right) => AndNot(left, right);
+
+        /// <summary>
+        /// float32x4_t vandn_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right) => AndNot(left, right);
+
+        /// <summary>
+        /// float64x2_t vandn_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VANDN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right) => AndNot(left, right);
+
+        /// <summary>
+        /// uint8x8_t vor(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<byte> Or(Vector64<byte> left, Vector64<byte> right) => Or(left, right);
+
+        /// <summary>
+        /// float64x1_t vor(float64x1_t a, float64x1_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<double> Or(Vector64<double> left, Vector64<double> right) => Or(left, right);
+
+        /// <summary>
+        /// int16x4_t vor(int16x4_t a, int16x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<short> Or(Vector64<short> left, Vector64<short> right) => Or(left, right);
+
+        /// <summary>
+        /// int32x2_t vor(int32x2_t a, int32x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<int> Or(Vector64<int> left, Vector64<int> right) => Or(left, right);
+
+        /// <summary>
+        /// int64x1_t vor(int64x1_t a, int64x1_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<long> Or(Vector64<long> left, Vector64<long> right) => Or(left, right);
+
+        /// <summary>
+        /// int8x8_t vor(int8x8_t a, int8x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<sbyte> Or(Vector64<sbyte> left, Vector64<sbyte> right) => Or(left, right);
+
+        /// <summary>
+        /// float32x2_t vor(float32x2_t a, float32x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<float> Or(Vector64<float> left, Vector64<float> right) => Or(left, right);
+
+        /// <summary>
+        /// uint16x4_t vor(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ushort> Or(Vector64<ushort> left, Vector64<ushort> right) => Or(left, right);
+
+        /// <summary>
+        /// uint32x2_t vor(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<uint> Or(Vector64<uint> left, Vector64<uint> right) => Or(left, right);
+
+        /// <summary>
+        /// uint64x1_t vor(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ulong> Or(Vector64<ulong> left, Vector64<ulong> right) => Or(left, right);
+
+        /// <summary>
+        /// int8x16_t vor_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right) => Or(left, right);
+
+        /// <summary>
+        /// uint8x16_t vor_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right) => Or(left, right);
+
+        /// <summary>
+        /// int16x8_t vor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> Or(Vector128<short> left, Vector128<short> right) => Or(left, right);
+
+        /// <summary>
+        /// uint16x8_t vor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right) => Or(left, right);
+
+        /// <summary>
+        /// int32x4_t vor_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> Or(Vector128<int> left, Vector128<int> right) => Or(left, right);
+
+        /// <summary>
+        /// uint32x4_t vor_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right) => Or(left, right);
+
+        /// <summary>
+        /// int64x2_t vor_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> Or(Vector128<long> left, Vector128<long> right) => Or(left, right);
+
+        /// <summary>
+        /// uint64x2_t vor_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right) => Or(left, right);
+
+        /// <summary>
+        /// float32x4_t vor_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> Or(Vector128<float> left, Vector128<float> right) => Or(left, right);
+
+        /// <summary>
+        /// float64x2_t vor_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> Or(Vector128<double> left, Vector128<double> right) => Or(left, right);
+
+        /// <summary>
+        /// uint8x8_t vnori_b(uint8x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<byte> Not(Vector64<byte> value) => Not(value);
+
+        /// <summary>
+        /// float64x1_t vnori_b(float64x1_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<double> Not(Vector64<double> value) => Not(value);
+
+        /// <summary>
+        /// int16x4_t vnori_b(int16x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<short> Not(Vector64<short> value) => Not(value);
+
+        /// <summary>
+        /// int32x2_t vnori_b(int32x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<int> Not(Vector64<int> value) => Not(value);
+
+        /// <summary>
+        /// int64x1_t vnori_b(int64x1_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<long> Not(Vector64<long> value) => Not(value);
+
+        /// <summary>
+        /// int8x8_t vnori_b(int8x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<sbyte> Not(Vector64<sbyte> value) => Not(value);
+
+        /// <summary>
+        /// float32x2_t vnori_b(float32x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<float> Not(Vector64<float> value) => Not(value);
+
+        /// <summary>
+        /// uint16x4_t vnori_b(uint16x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<ushort> Not(Vector64<ushort> value) => Not(value);
+
+        /// <summary>
+        /// uint32x2_t vnori_b(uint32x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<uint> Not(Vector64<uint> value) => Not(value);
+
+        /// <summary>
+        /// uint64x1_t vnori_b(uint64x1_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector64<ulong> Not(Vector64<ulong> value) => Not(value);
+
+        /// <summary>
+        /// uint8x16_t vnori_b(uint8x16_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<byte> Not(Vector128<byte> value) => Not(value);
+
+        /// <summary>
+        /// float64x2_t vnori_b(float64x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<double> Not(Vector128<double> value) => Not(value);
+
+        /// <summary>
+        /// int16x8_t vnori_b(int16x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<short> Not(Vector128<short> value) => Not(value);
+
+        /// <summary>
+        /// int32x4_t vnori_b(int32x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<int> Not(Vector128<int> value) => Not(value);
+
+        /// <summary>
+        /// int64x2_t vnori_b(int64x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<long> Not(Vector128<long> value) => Not(value);
+
+        /// <summary>
+        /// int8x16_t vnori_b(int8x16_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<sbyte> Not(Vector128<sbyte> value) => Not(value);
+
+        /// <summary>
+        /// float32x4_t vnori_b(float32x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<float> Not(Vector128<float> value) => Not(value);
+
+        /// <summary>
+        /// uint16x8_t vnori_b(uint16x8_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<ushort> Not(Vector128<ushort> value) => Not(value);
+
+        /// <summary>
+        /// uint32x4_t vnori_b(uint32x4_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static Vector128<uint> Not(Vector128<uint> value) => Not(value);
+
+        /// <summary>
+        /// uint64x2_t vnori_b(uint64x2_t a)
+        ///   LSX: VNORI.B Vd.16B, Vj.16B, 0
+        /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs.
+        /// </summary>
+        public static Vector128<ulong> Not(Vector128<ulong> value) => Not(value);
+
+        /// <summary>
+        /// int8x16_t vnor_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VNOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> NotOr(Vector128<sbyte> left, Vector128<sbyte> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint8x16_t vnor_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VNOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> NotOr(Vector128<byte> left, Vector128<byte> right) => NotOr(left, right);
+
+        /// <summary>
+        /// int16x8_t vnor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VNOR.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> NotOr(Vector128<short> left, Vector128<short> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint16x8_t vnor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VNOR.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> NotOr(Vector128<ushort> left, Vector128<ushort> right) => NotOr(left, right);
+
+        /// <summary>
+        /// int32x4_t vnor_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VNOR.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> NotOr(Vector128<int> left, Vector128<int> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint32x4_t vnor_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VNOR.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> NotOr(Vector128<uint> left, Vector128<uint> right) => NotOr(left, right);
+
+        /// <summary>
+        /// int64x2_t vnor_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VNOR.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> NotOr(Vector128<long> left, Vector128<long> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint64x2_t vnor_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VNOR.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> NotOr(Vector128<ulong> left, Vector128<ulong> right) => NotOr(left, right);
+
+        /// <summary>
+        /// float32x4_t vnor_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VNOR.V Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> NotOr(Vector128<float> left, Vector128<float> right) => NotOr(left, right);
+
+        /// <summary>
+        /// float64x2_t vnor_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VNOR.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> NotOr(Vector128<double> left, Vector128<double> right) => NotOr(left, right);
+
+        /// <summary>
+        /// uint8x8_t vorn(uint8x8_t a, uint8x8_t b)
+        /// </summary>
+        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float64x1_t vorn(float64x1_t a, float64x1_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int16x4_t vorn(int16x4_t a, int16x4_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int32x2_t vorn(int32x2_t a, int32x2_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int64x1_t vorn(int64x1_t a, int64x1_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int8x8_t vorn(int8x8_t a, int8x8_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float32x2_t vorn(float32x2_t a, float32x2_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint16x4_t vorn(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint32x2_t vorn(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint64x1_t vorn(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int8x16_t vorn_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> OrNot(Vector128<sbyte> left, Vector128<sbyte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint8x16_t vorn_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VORN.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> OrNot(Vector128<byte> left, Vector128<byte> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int16x8_t vor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VORN.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> OrNot(Vector128<short> left, Vector128<short> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint16x8_t vor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VORN.V Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> OrNot(Vector128<ushort> left, Vector128<ushort> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int32x4_t vorn_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VORN.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> OrNot(Vector128<int> left, Vector128<int> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint32x4_t vorn_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VORN.V Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> OrNot(Vector128<uint> left, Vector128<uint> right) => OrNot(left, right);
+
+        /// <summary>
+        /// int64x2_t vorn_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VORN.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> OrNot(Vector128<long> left, Vector128<long> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint64x2_t vorn_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VORN.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> OrNot(Vector128<ulong> left, Vector128<ulong> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float32x4_t vorn_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VORN.V Vd.4S, Vj.4S, Vk.4S
+        /// </summary>
+        public static Vector128<float> OrNot(Vector128<float> left, Vector128<float> right) => OrNot(left, right);
+
+        /// <summary>
+        /// float64x2_t vorn_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VORN.V Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<double> OrNot(Vector128<double> left, Vector128<double> right) => OrNot(left, right);
+
+        /// <summary>
+        /// uint8x8_t vxor(uint8x8_t a, uint8x8_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<byte> Xor(Vector64<byte> left, Vector64<byte> right) => Xor(left, right);
+
+        /// <summary>
+        /// float64x1_t vxor(float64x1_t a, float64x1_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<double> Xor(Vector64<double> left, Vector64<double> right) => Xor(left, right);
+
+        /// <summary>
+        /// int16x4_t vxor(int16x4_t a, int16x4_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<short> Xor(Vector64<short> left, Vector64<short> right) => Xor(left, right);
+
+        /// <summary>
+        /// int32x2_t vxor(int32x2_t a, int32x2_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<int> Xor(Vector64<int> left, Vector64<int> right) => Xor(left, right);
+
+        /// <summary>
+        /// int64x1_t vxor(int64x1_t a, int64x1_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<long> Xor(Vector64<long> left, Vector64<long> right) => Xor(left, right);
+
+        /// <summary>
+        /// int8x8_t vxor(int8x8_t a, int8x8_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<sbyte> Xor(Vector64<sbyte> left, Vector64<sbyte> right) => Xor(left, right);
+
+        /// <summary>
+        /// float32x2_t vxor(float32x2_t a, float32x2_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<float> Xor(Vector64<float> left, Vector64<float> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint16x4_t vxor(uint16x4_t a, uint16x4_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<ushort> Xor(Vector64<ushort> left, Vector64<ushort> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint32x2_t vxor(uint32x2_t a, uint32x2_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<uint> Xor(Vector64<uint> left, Vector64<uint> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint64x1_t vxor(uint64x1_t a, uint64x1_t b)
+        ///   LSX: VXOR.V Vd.8B, Vj.8B, Vk.8B
+        /// </summary>
+        public static Vector64<ulong> Xor(Vector64<ulong> left, Vector64<ulong> right) => Xor(left, right);
+
+        /// <summary>
+        /// int8x16_t vxor_v(int8x16_t a, int8x16_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint8x16_t vxor_v(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right) => Xor(left, right);
+
+        /// <summary>
+        /// int16x8_t vxor_v(int16x8_t a, int16x8_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint16x8_t vxor_v(uint16x8_t a, uint16x8_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right) => Xor(left, right);
+
+        /// <summary>
+        /// int32x4_t vxor_v(int32x4_t a, int32x4_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint32x4_t vxor_v(uint32x4_t a, uint32x4_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right) => Xor(left, right);
+
+        /// <summary>
+        /// int64x2_t vxor_v(int64x2_t a, int64x2_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right) => Xor(left, right);
+
+        /// <summary>
+        /// uint64x2_t vxor_v(uint64x2_t a, uint64x2_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right) => Xor(left, right);
+
+        /// <summary>
+        /// float32x4_t vxor_v(float32x4_t a, float32x4_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right) => Xor(left, right);
+
+        /// <summary>
+        /// float64x2_t vxor_v(float64x2_t a, float64x2_t b)
+        ///   LSX: VXOR.V Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right) => Xor(left, right);
+
+        /// <summary>
+        /// int8x16_t vslli_b(int8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vslli_b(uint8x16_t a, const int n)
+        ///   LSX: VSLLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int16x8_t vslli_h(int16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vslli_h(uint16x8_t a, const int n)
+        ///   LSX: VSLLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vslli_w(uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vslli_w(uint32x4_t a, const int n)
+        ///   LSX: VSLLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int64x2_t vslli_d(int64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vslli_d(uint64x2_t a, const int n)
+        ///   LSX: VSLLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, const byte shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int8x16_t vbsll_v(int8x16_t a, const int shift)
+        ///   LSX: VBSLL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogicalByByte(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftLogicalByByte(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vbsll_v(uint8x16_t a, const int shift)
+        ///   LSX: VBSLL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogicalByByte(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftLogicalByByte(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsll_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSLL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, Vector128<sbyte> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsll_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSLL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, Vector128<byte> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsll_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSLL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftLeftLogical(Vector128<short> value, Vector128<short> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsll_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSLL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, Vector128<ushort> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsll_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSLL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftLeftLogical(Vector128<int> value, Vector128<int> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsll_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSLL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsll_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSLL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftLeftLogical(Vector128<long> value, Vector128<long> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsll_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSLL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, Vector128<ulong> shift) => ShiftLeftLogical(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrli_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrli_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrli_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrli_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrli_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrli_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsrli_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsrli_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, const byte shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int8x16_t vbsrl_v(int8x16_t a, const int shift)
+        ///   LSX: VBSRL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalByByte(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalByByte(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vbsrl_v(uint8x16_t a, const int shift)
+        ///   LSX: VBSRL.V Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalByByte(Vector128<byte> value, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalByByte(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrl_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSRL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, Vector128<sbyte> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrl_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSRL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, Vector128<byte> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsrl_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrl_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsrl_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightLogical(Vector128<int> value, Vector128<int> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrl_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsrl_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightLogical(Vector128<long> value, Vector128<long> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsrl_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogical(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrlri_b(uint8x16_t a, const int n)
+        ///   LSX: VSRLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrlri_h(uint16x8_t a, const int n)
+        ///   LSX: VSRLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrlri_w(uint32x4_t a, const int n)
+        ///   LSX: VSRLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsrlri_d(uint64x2_t a, const int n)
+        ///   LSX: VSRLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, const byte shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrlr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSRLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, Vector128<sbyte> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrlr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSRLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, Vector128<byte> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsrlr_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrlr_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsrlr_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, Vector128<int> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrlr_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsrlr_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, Vector128<long> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vsrlr_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalRounded(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsrlrni_b_h(uint16x8_t left, uint16x8_t right, const int n)
+        ///   LSX: VSRLRNI.B.H Vd, Vj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x16_t vsrlrni_b_h(int16x8_t left, int16x8_t right, const int n)
+        ///   LSX: VSRLRNI.B.H Vd, Vj, ui4
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vsrlrni_h_w(int32x4_t left, int32x4_t right, const int n)
+        ///   LSX: VSRLRNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrlrni_h_w(uint32x4_t left, uint32x4_t right, const int n)
+        ///   LSX: VSRLRNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vsrlrni_w_d(int64x2_t left, int64x2_t right, const int n)
+        ///   LSX: VSRLRNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrlrni_w_d(uint64x2_t left, uint64x2_t right, const int n)
+        ///   LSX: VSRLRNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vsrlrni_d_q(int128x1_t left, int128x1_t right, const int n)
+        /////   LSX: VSRLRNI.D.Q Vd, Vj, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vsrlrn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint8x8_t vsrlrn_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vsrlrn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, Vector128<int> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vsrlrn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vsrlrn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, Vector128<long> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vsrlrn_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrai_b(int8x16_t a, const int n)
+        ///   LSX: VSRAI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsrai_h(int16x8_t a, const int n)
+        ///   LSX: VSRAI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsrai_w(int32x4_t a, const int n)
+        ///   LSX: VSRAI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsrai_d(int64x2_t a, const int n)
+        ///   LSX: VSRAI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, const byte shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vsra_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VSRA.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmetic(Vector128<byte> value, Vector128<byte> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsra_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRA.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsra_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRA.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsra_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRA.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmetic(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrari_b(int8x16_t a, const int n)
+        ///   LSX: VSRARI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsrari_h(int16x8_t a, const int n)
+        ///   LSX: VSRARI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsrari_w(int32x4_t a, const int n)
+        ///   LSX: VSRARI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsrari_d(int64x2_t a, const int n)
+        ///   LSX: VSRARI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, const byte shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrar_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VSRAR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, Vector128<sbyte> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int16x8_t vsrar_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRAR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int32x4_t vsrar_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRAR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int64x2_t vsrar_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRAR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmeticRounded(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsrarni_b_h(int16x8_t left, int16x8_t right, const int n)
+        ///   LSX: VSRARNI.B.H Vd, Vj, ui4    ///NOTE: The Vd is both input and output, so the left shoule be ref type!!!
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vsrarni_h_w(int32x4_t left, int32x4_t right, const int n)
+        ///   LSX: VSRARNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vsrarni_w_d(int64x2_t left, int64x2_t right, const int n)
+        ///   LSX: VSRARNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vsrarni_d_q(int128x1_t left, int128x1_t right, const int n)
+        /////   LSX: VSRARNI.D.Q Vd, Vj, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vsrarn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRARN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingLower(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmeticRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vsrarn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRARN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingLower(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmeticRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vsrarn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRARN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightArithmeticRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vsrarn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRARN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingLower(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmeticRoundedNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vrotri_b(uint8x16_t a, const int n)
+        ///   LSX: VROTRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> RotateRight(Vector128<sbyte> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vrotri_b(uint8x16_t a, const int n)
+        ///   LSX: VROTRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> RotateRight(Vector128<byte> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vrotri_h(uint16x8_t a, const int n)
+        ///   LSX: VROTRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> RotateRight(Vector128<short> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vrotri_h(uint16x8_t a, const int n)
+        ///   LSX: VROTRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> RotateRight(Vector128<ushort> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vrotri_w(uint32x4_t a, const int n)
+        ///   LSX: VROTRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> RotateRight(Vector128<int> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vrotri_w(uint32x4_t a, const int n)
+        ///   LSX: VROTRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> RotateRight(Vector128<uint> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vrotri_d(uint64x2_t a, const int n)
+        ///   LSX: VROTRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> RotateRight(Vector128<long> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vrotri_d(uint64x2_t a, const int n)
+        ///   LSX: VROTRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> RotateRight(Vector128<ulong> value, const byte shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int8x16_t vrotr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VROTR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> RotateRight(Vector128<sbyte> value, Vector128<sbyte> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint8x16_t vrotr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VROTR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> RotateRight(Vector128<byte> value, Vector128<byte> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int16x8_t vrotr_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VROTR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> RotateRight(Vector128<short> value, Vector128<short> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vrotr_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VROTR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> RotateRight(Vector128<ushort> value, Vector128<ushort> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int32x4_t vrotr_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VROTR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> RotateRight(Vector128<int> value, Vector128<int> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint32x4_t vrotr_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VROTR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> RotateRight(Vector128<uint> value, Vector128<uint> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int64x2_t vrotr_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VROTR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> RotateRight(Vector128<long> value, Vector128<long> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// uint64x2_t vrotr_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VROTR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> RotateRight(Vector128<ulong> value, Vector128<ulong> shift) => RotateRight(value, shift);
+
+        /// <summary>
+        /// int8x16_t vsigncov_b(int8x16_t a)
+        ///   LSX: VSIGNCOV.B Vd.16B, Vj.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> Abs(Vector128<sbyte> value) => Abs(value);
+
+        /// <summary>
+        /// int16x8_t vsigncov_h(int16x8_t a)
+        ///   LSX: VSIGNCOV.H Vd.8H, Vj.8H, Vj.8H
+        /// </summary>
+        public static Vector128<ushort> Abs(Vector128<short> value) => Abs(value);
+
+        /// <summary>
+        /// int32x4_t vsigncov_w(int32x4_t a)
+        ///   LSX: VSIGNCOV.W Vd.4W, Vj.4W, Vj.4W
+        /// </summary>
+        public static Vector128<uint> Abs(Vector128<int> value) => Abs(value);
+
+        /// <summary>
+        /// int64x2_t vsigncov_d(int64x2_t a)
+        ///   LSX: VSIGNCOV.D Vd.2D, Vj.2D, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> Abs(Vector128<long> value) => Abs(value);
+
+        /// <summary>
+        /// float32x4_t vbitclri_w(float32x4_t a)
+        ///   LSX: VBITCLRI.W Vd.4S, Vj.4S, 31
+        /// </summary>
+        public static Vector128<float> Abs(Vector128<float> value) => Abs(value);
+
+        /// <summary>
+        /// float64x2_t vbitclri_d(float64x2_t a)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, 63
+        /// </summary>
+        public static Vector128<double> Abs(Vector128<double> value) => Abs(value);
+
+        /// <summary>
+        /// float32x4_t vfrintrm_s(float32x4_t a)
+        ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Floor(Vector128<float> value) => Floor(value);
+
+        /// <summary>
+        /// float64x2_t vfrintrm_d(float64x2_t a)
+        ///   LSX: VFRINTRM.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Floor(Vector128<double> value) => Floor(value);
+
+        /// <summary>
+        /// float32x4_t vfrintrp_s(float32x4_t a)
+        ///   LSX: VFRINTRP.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> Ceiling(Vector128<float> value) => Ceiling(value);
+
+        /// <summary>
+        /// float64x2_t vfrintrp_d(float64x2_t a)
+        ///   LSX: VFRINTRP.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> Ceiling(Vector128<double> value) => Ceiling(value);
+
+        /// <summary>
+        /// float32x4_t vfrintrz_s(float32x4_t a)
+        ///   LSX: VFRINTRZ.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> RoundToZero(Vector128<float> value) => RoundToZero(value);
+
+        /// <summary>
+        /// float64x2_t vfrintrz_d(float64x2_t a)
+        ///   LSX: VFRINTRZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> RoundToZero(Vector128<double> value) => RoundToZero(value);
+
+        /// <summary>
+        /// float32x4_t vfrintrm_s(float32x4_t a)
+        ///   LSX: VFRINTRM.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value) => RoundToNegativeInfinity(value);
+
+        /// <summary>
+        /// float64x2_t vfrintrm_d(float64x2_t a)
+        ///   LSX: VFRINTRM.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value) => RoundToNegativeInfinity(value);
+
+        /// <summary>
+        /// float32x4_t vfrintrp_s(float32x4_t a)
+        ///   LSX: VFRINTRP.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value) => RoundToPositiveInfinity(value);
+
+        /// <summary>
+        /// float64x2_t vfrintrp_d(float64x2_t a)
+        ///   LSX: VFRINTRP.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value) => RoundToPositiveInfinity(value);
+
+        /// <summary>
+        /// int8x16_t vinsgr2vr_b(int8x16_t v, int8_t data, const int index)
+        ///   LSX: VINSGR2VR.B Vd.B, Rj, ui4
+        /// </summary>
+        public static Vector128<sbyte> Insert(Vector128<sbyte> vector, sbyte data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// uint8x16_t vinsgr2vr_b(uint8x16_t v, uint8_t data, const int index)
+        ///   LSX: VINSGR2VR.B Vd.B, Rj, ui4
+        /// </summary>
+        public static Vector128<byte> Insert(Vector128<byte> vector, byte data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int16x8_t vinsgr2vr_h(int16x8_t v, int16_t data, const int index)
+        ///   LSX: VINSGR2VR.H Vd.H, Rj, ui3
+        /// </summary>
+        public static Vector128<short> Insert(Vector128<short> vector, short data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// uint16x8_t vinsgr2vr_h(uint16x8_t v, uint16_t data, const int index)
+        ///   LSX: VINSGR2VR.H Vd.H, Rj, ui3
+        /// </summary>
+        public static Vector128<ushort> Insert(Vector128<ushort> vector, ushort data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int32x4_t vinsgr2vr_w(int32x4_t v, int32_t data, const int index)
+        ///   LSX: VINSGR2VR.W Vd.S, Rj, ui2
+        /// </summary>
+        public static Vector128<int> Insert(Vector128<int> vector, int data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// uint32x4_t vinsgr2vr_w(uint32x4_t v, uint32_t data, const int index)
+        ///   LSX: VINSGR2VR.W Vd.S, Rj, ui2
+        /// </summary>
+        public static Vector128<uint> Insert(Vector128<uint> vector, uint data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int64x2_t vinsgr2vr_d(int64x2_t v, int64_t data, const int index)
+        ///   LSX: VINSGR2VR.D Vd.D, Rj, ui1
+        /// </summary>
+        public static Vector128<long> Insert(Vector128<long> vector, long data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// uint64x2_t vinsgr2vr_d(uint64x2_t v, uint64_t data, const int index)
+        ///   LSX: VINSGR2VR.D Vd.D, Rj, ui1
+        /// </summary>
+        public static Vector128<ulong> Insert(Vector128<ulong> vector, ulong data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// float32x4_t xvinsve0_w(float32x4_t v, float32_t data, const int index)
+        ///   LSX: VEXTRINS.W  Vd.S, Vj.S, ui8
+        /// </summary>
+        public static Vector128<float> Insert(Vector128<float> vector, float data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// float64x2_t xvinsve0_d(float64x2_t v, float64_t data, const int index)
+        ///   LSX: VEXTRINS.D  Vd.D, Vj.D, ui8
+        /// </summary>
+        public static Vector128<double> Insert(Vector128<double> vector, double data, const byte index) => Insert(vector, data, index);
+
+        /// <summary>
+        /// int8x16_t vreplgr2vr_b(int8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// </summary>
+        public static Vector128<sbyte> DuplicateToVector128(sbyte value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint8x16_t vreplgr2vr_b(uint8_t value)
+        ///   LSX: VREPLGR2VR.B Vd.16B, Rj
+        /// </summary>
+        public static Vector128<byte> DuplicateToVector128(byte value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// int16x8_t vreplgr2vr_h(int16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// </summary>
+        public static Vector128<short> DuplicateToVector128(short value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint16x8_t vreplgr2vr_h(uint16_t value)
+        ///   LSX: VREPLGR2VR.H Vd.8H, Rj
+        /// </summary>
+        public static Vector128<ushort> DuplicateToVector128(ushort value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// int32x4_t vreplgr2vr_w(int32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
+        /// </summary>
+        public static Vector128<int> DuplicateToVector128(int value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint32x4_t vreplgr2vr_w(uint32_t value)
+        ///   LSX: VREPLGR2VR.W Vd.4W, Rj
+        /// </summary>
+        public static Vector128<uint> DuplicateToVector128(uint value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// int64x2_t vreplgr2vr_d(int64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// </summary>
+        public static Vector128<long> DuplicateToVector128(long value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// uint64x2_t vreplgr2vr_d(uint64_t value)
+        ///   LSX: VREPLGR2VR.D Vd.2D, Rj
+        /// </summary>
+        public static Vector128<ulong> DuplicateToVector128(ulong value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// float32x4_t xvreplve0_w(float32_t value)
+        ///   LSX: XVREPLVE0.W Vd.4S, Vj.S[0]
+        /// </summary>
+        public static Vector128<float> DuplicateToVector128(float value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// float64x2_t xvreplve0_d(float64_t value)
+        ///   LSX: XVREPLVE0.D Vd.2D, Vj.D[0]
+        /// </summary>
+        public static Vector128<double> DuplicateToVector128(double value) => DuplicateToVector128(value);
+
+        /// <summary>
+        /// float32x4_t vffint_s_w(int32x4_t a)
+        ///   LSX: VFFINT.S.W Vd.4S, Vj.4W
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<int> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float32x4_t vffint_s_wu(uint32x4_t a)
+        ///   LSX: VFFINT.S.WU Vd.4S, Vj.4W
+        /// </summary>
+        public static Vector128<float> ConvertToSingle(Vector128<uint> value) => ConvertToSingle(value);
+
+        /// <summary>
+        /// float64x2_t vffint_d_l(int64x2_t a)
+        ///   LSX: VFFINT.D.L Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> ConvertToDouble(Vector128<long> value) => ConvertToDouble(value);
+
+        /// <summary>
+        /// float64x2_t vffint_d_lu(uint64x2_t a)
+        ///   LSX: VFFINT.D.LU Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<double> ConvertToDouble(Vector128<ulong> value) => ConvertToDouble(value);
+
+        /// <summary>
+        /// int8_t vfsrtpi_b(uint8x16_t value)
+        ///   LSX: VFSRTPI.B Vd.16B, Vj.16B, 0
+        /// </summary>
+        public static byte FirstNegativeInteger(Vector128<byte> value) => FirstNegativeInteger(value);
+
+        /// <summary>
+        /// int16_t vfsrtpi_h(uint16x8_t value)
+        ///   LSX: VFSRTPI.H Vd.8H, Vj.8H, 0
+        /// </summary>
+        public static ushort FirstNegativeInteger(Vector128<ushort> value) => FirstNegativeInteger(value);
+
+        /// <summary>
+        /// bool vsetnez_v(uint8x16_t value)
+        ///   LSX: VSETNEZ.V cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsNotZero(Vector128<byte> value) => HasElementsNotZero(value);
+
+        /// <summary>
+        /// bool vseteqz_v(uint8x16_t value)
+        ///   LSX: VSETEQZ.V cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsIsZero(Vector128<byte> value) => AllElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_b(int8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<sbyte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_b(uint8x16_t value)
+        ///   LSX: VSETALLNEZ.B cd, Vj.16B
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<byte> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_h(int16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<short> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_h(uint16x8_t value)
+        ///   LSX: VSETALLNEZ.H cd, Vj.8H
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ushort> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w(int32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<int> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w(uint32x4_t value)
+        ///   LSX: VSETALLNEZ.W cd, Vj.4W
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<uint> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w(int64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<long> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetallnez_w(uint64x2_t value)
+        ///   LSX: VSETALLNEZ.D cd, Vj.2D
+        /// </summary>
+        public static bool AllElementsNotZero(Vector128<ulong> value) => AllElementsNotZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_b(int8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<sbyte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_b(uint8x16_t value)
+        ///   LSX: VSETANYEQZ.B cd, Vj.16B
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<byte> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_h(int16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<short> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_h(uint16x8_t value)
+        ///   LSX: VSETANYEQZ.H cd, Vj.8H
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ushort> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w(int32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<int> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w(uint32x4_t value)
+        ///   LSX: VSETANYEQZ.W cd, Vj.4W
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<uint> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w(int64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<long> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// bool vsetanyeqz_w(uint64x2_t value)
+        ///   LSX: VSETANYEQZ.D cd, Vj.2D
+        /// </summary>
+        public static bool HasElementsIsZero(Vector128<ulong> value) => HasElementsIsZero(value);
+
+        /// <summary>
+        /// uint8x16_t vsrlni_b_h(uint16x8_t left, uint16x8_t right, shift)
+        ///   LSX: VSRLNI.B.H Vd, Vj, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> left, Vector128<ushort> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vsrlni_h_w(int32x4_t left, int32x4_t right, shift)
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingLower(Vector128<int> left, Vector128<int> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vsrlni_h_w(uint32x4_t left, uint32x4_t right, shift)
+        ///   LSX: VSRLNI.H.W Vd, Vj, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> left, Vector128<uint> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vsrlni_w_d(int64x2_t left, int64x2_t right, shift)
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingLower(Vector128<long> left, Vector128<long> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vsrlni_w_d(uint64x2_t left, uint64x2_t right, shift)
+        ///   LSX: VSRLNI.W.D Vd, Vj, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> left, Vector128<ulong> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x2_t vsrlni_d_q(uint128x1_t left, uint128x1_t right, shift)
+        /////   LSX: VSRLNI.D.Q Vd.Q, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightLogicalNarrowingLower(Vector128<ulonglong> left, Vector128<ulonglong> right, byte shift) => ShiftRightLogicalNarrowingLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vsrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint8x8_t vsrln_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vsrln_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, Vector128<int> shift) => ShiftRightLogicalNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vsrln_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vsrln_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, Vector128<long> shift) => ShiftRightLogicalNarrowingLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vsrln_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalNarrowingLower(value, shift);
+
+        /// <summary>
+        /// int16x8_t vssrlni_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRLNI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlni_b_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLNI.B.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vssrlni_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRLNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlni_h_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vssrlni_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRLNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vssrlni_w_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vssrlni_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRLNI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightLogicalNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vssrln_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint8x8_t vssrln_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vssrln_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) => ShiftRightLogicalNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vssrln_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vssrln_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) => ShiftRightLogicalNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vssrln_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlni_bu_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLNI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlni_hu_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLNI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vssrlni_wu_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLNI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x2_t vssrlni_du_q(uint128x1_t left, uint128x1_t right, const byte n)
+        /////   LSX: VSSRLNI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulonglong> left, Vector128<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint8x8_t vssrln_bu_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vssrln_hu_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vssrln_wu_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// int16x8_t vssran_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRANI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vssran_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRANI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vssran_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRANI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vssran_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRANI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightArithmeticNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vssran_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRAN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmeticNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vssran_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRAN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmeticNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vssran_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRAN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmeticNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrani_bu_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRANI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrani_hu_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRANI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vssrani_wu_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRANI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x2_t vssrani_du_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRANI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint8x8_t vssran_bu_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRAN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vssran_hu_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRAN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vssran_wu_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRAN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// int16x8_t vssrlrni_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRLRNI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_b_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLRNI.B.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vssrlrni_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRLRNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_h_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLRNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vssrlrni_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRLRNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vssrlrni_w_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLRNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vssrlrni_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRLRNI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vssrlrn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint8x8_t vssrlrn_b_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLRN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vssrlrn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vssrlrn_h_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLRN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vssrlrn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vssrlrn_w_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLRN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_bu_h(uint16x8_t left, uint16x8_t right, const byte n)
+        ///   LSX: VSSRLRNI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> left, Vector128<ushort> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrlrni_hu_w(uint32x4_t left, uint32x4_t right, const byte n)
+        ///   LSX: VSSRLRNI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> left, Vector128<uint> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vssrlrni_wu_d(uint64x2_t left, uint64x2_t right, const byte n)
+        ///   LSX: VSSRLRNI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> left, Vector128<ulong> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x2_t vssrlrni_du_q(uint128x1_t left, uint128x1_t right, const byte n)
+        /////   LSX: VSSRLRNI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulonglong> left, Vector128<ulonglong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint8x8_t vssrlrn_bu_h(uint16x8_t value, uint16x8_t shift)
+        ///   LSX: VSSRLRN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ushort> value, Vector128<ushort> shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vssrlrn_hu_w(uint32x4_t value, uint32x4_t shift)
+        ///   LSX: VSSRLRN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<uint> value, Vector128<uint> shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vssrlrn_wu_d(uint64x2_t value, uint64x2_t shift)
+        ///   LSX: VSSRLRN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(Vector128<ulong> value, Vector128<ulong> shift) => ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// int16x8_t vssrarn_b_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRARNI.B.H Vd.16B, Vj.8H, ui4  ///NOTE: the Vd is both input and output.
+        /// </summary>
+        public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int16x8_t vssrarn_h_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRARNI.H.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int32x4_t vssrarn_w_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRARNI.W.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+
+        ///// <summary>
+        ///// int64x2_t vssrarn_d_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRARNI.D.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<long> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(left, right, shift);
+
+        /// <summary>
+        /// int8x8_t vssrarn_b_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRARN.B.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int16x4_t vssrarn_h_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRARN.H.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// int32x2_t vssrarn_w_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRARN.W.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrarni_bu_h(int16x8_t left, int16x8_t right, const byte n)
+        ///   LSX: VSSRARNI.BU.H Vd.16B, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> left, Vector128<short> right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint16x8_t vssrarni_hu_w(int32x4_t left, int32x4_t right, const byte n)
+        ///   LSX: VSSRARNI.HU.W Vd.8H, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> left, Vector128<int> right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint32x4_t vssrarni_wu_d(int64x2_t left, int64x2_t right, const byte n)
+        ///   LSX: VSSRARNI.WU.D Vd.4W, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> left, Vector128<long> right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        ///// <summary>
+        ///// uint64x2_t vssrarni_du_q(int128x1_t left, int128x1_t right, const byte n)
+        /////   LSX: VSSRARNI.DU.Q Vd.2D, Vj.Q, ui7
+        ///// </summary>
+        //public static Vector128<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<longlong> left, Vector128<longlong> right, [ConstantExpected(Max = (byte)(127))] byte shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(left, right, shift);
+
+        /// <summary>
+        /// uint8x8_t vssrarn_bu_h(int16x8_t value, int16x8_t shift)
+        ///   LSX: VSSRARN.BU.H Vd.8B, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, Vector128<short> shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint16x4_t vssrarn_hu_w(int32x4_t value, int32x4_t shift)
+        ///   LSX: VSSRARN.HU.W Vd.4H, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, Vector128<int> shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// uint32x2_t vssrarn_wu_d(int64x2_t value, int64x2_t shift)
+        ///   LSX: VSSRARN.WU.D Vd.2W, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, Vector128<long> shift) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, shift);
+
+        /// <summary>
+        /// int8x8_t vclo_b(int8x8_t a)
+        ///   LSX: VCLO.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int16x4_t vclo_h(int16x4_t a)
+        ///   LSX: VCLO.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<short> LeadingSignCount(Vector64<short> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int32x2_t vclo_w(int32x2_t a)
+        ///   LSX: VCLO.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<int> LeadingSignCount(Vector64<int> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int64x1_t vclo_d(int64x1_t a)
+        ///   LSX: VCLO.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<long> LeadingSignCount(Vector64<long> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int8x16_t vclo_b(int8x16_t a)
+        ///   LSX: VCLO.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int16x8_t vclo_h(int16x8_t a)
+        ///   LSX: VCLO.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> LeadingSignCount(Vector128<short> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int32x4_t vclo_w(int32x4_t a)
+        ///   LSX: VCLO.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> LeadingSignCount(Vector128<int> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// int64x2_t vclo_d(int64x2_t a)
+        ///   LSX: VCLO.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> LeadingSignCount(Vector128<long> value) => LeadingSignCount(value);
+
+        /// <summary>
+        /// uint8x8_t vclz_b(uint8x8_t a)
+        ///   LSX: VCLZ.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<byte> LeadingZeroCount(Vector64<byte> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int8x8_t vclz_b(int8x8_t a)
+        ///   LSX: VCLZ.B Vd.8B, Vj.8B
+        /// </summary>
+        public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int16x4_t vclz_h(int16x4_t a)
+        ///   LSX: VCLZ.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<short> LeadingZeroCount(Vector64<short> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint16x4_t vclz_h(uint16x4_t a)
+        ///   LSX: VCLZ.H Vd.4H, Vj.4H
+        /// </summary>
+        public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int32x2_t vclz_w(int32x2_t a)
+        ///   LSX: VCLZ.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<int> LeadingZeroCount(Vector64<int> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint32x2_t vclz_w(uint32x2_t a)
+        ///   LSX: VCLZ.W Vd.2W, Vj.2W
+        /// </summary>
+        public static Vector64<uint> LeadingZeroCount(Vector64<uint> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int64x1_t vclz_d(int64x1_t a)
+        ///   LSX: VCLZ.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<long> LeadingZeroCount(Vector64<long> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint64x1_t vclz_d(uint64x1_t a)
+        ///   LSX: VCLZ.D Vd.D, Vj.D
+        /// </summary>
+        public static Vector64<ulong> LeadingZeroCount(Vector64<ulong> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int8x16_t vclz_b(int8x16_t a)
+        ///   LSX: VCLZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint8x16_t vclz_b(uint8x16_t a)
+        ///   LSX: VCLZ.B Vd.16B, Vj.16B
+        /// </summary>
+        public static Vector128<byte> LeadingZeroCount(Vector128<byte> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int16x8_t vclz_h(int16x8_t a)
+        ///   LSX: VCLZ.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<short> LeadingZeroCount(Vector128<short> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint16x8_t vclz_h(uint16x8_t a)
+        ///   LSX: VCLZ.H Vd.8H, Vj.8H
+        /// </summary>
+        public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int32x4_t vclz_w(int32x4_t a)
+        ///   LSX: VCLZ.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<int> LeadingZeroCount(Vector128<int> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint32x4_t vclz_w(uint32x4_t a)
+        ///   LSX: VCLZ.W Vd.4W, Vj.4W
+        /// </summary>
+        public static Vector128<uint> LeadingZeroCount(Vector128<uint> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int64x2_t vclz_d(int64x2_t a)
+        ///   LSX: VCLZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> LeadingZeroCount(Vector128<long> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// uint64x2_t vclz_d(uint64x2_t a)
+        ///   LSX: VCLZ.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<ulong> LeadingZeroCount(Vector128<ulong> value) => LeadingZeroCount(value);
+
+        /// <summary>
+        /// int8x16_t vpcnt_b(int8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<sbyte> PopCount(Vector128<sbyte> value) => PopCount(value);
+
+        /// <summary>
+        /// uint8x16_t vpcnt_b(uint8x16_t a)
+        ///   LSX: VPCNT_B Vd, Vj
+        /// </summary>
+        public static Vector128<byte> PopCount(Vector128<byte> value) => PopCount(value);
+
+        /// <summary>
+        /// int16x8_t vpcnt_h(int16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<short> PopCount(Vector128<short> value) => PopCount(value);
+
+        /// <summary>
+        /// uint16x8_t vpcnt_h(uint16x8_t a)
+        ///   LSX: VPCNT_H Vd, Vj
+        /// </summary>
+        public static Vector128<ushort> PopCount(Vector128<ushort> value) => PopCount(value);
+
+        /// <summary>
+        /// int32x4_t vpcnt_w(int32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<int> PopCount(Vector128<int> value) => PopCount(value);
+
+        /// <summary>
+        /// uint32x4_t vpcnt_w(uint32x4_t a)
+        ///   LSX: VPCNT_W Vd, Vj
+        /// </summary>
+        public static Vector128<uint> PopCount(Vector128<uint> value) => PopCount(value);
+
+        /// <summary>
+        /// int64x2_t vpcnt_d(int64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<long> PopCount(Vector128<long> value) => PopCount(value);
+
+        /// <summary>
+        /// uint64x2_t vpcnt_d(uint64x2_t a)
+        ///   LSX: VPCNT_D Vd, Vj
+        /// </summary>
+        public static Vector128<ulong> PopCount(Vector128<ulong> value) => PopCount(value);
+
+        /// <summary>
+        ///  uint8x16_t vshuf_b(uint8x16_t vec, uint8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector, Vector128<byte> indexs) => VectorShuffle(vector, indexs);
+
+        /// <summary>
+        ///  int8x16_t vshuf_b(int8x16_t vec, int8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector, Vector128<sbyte> indexs) => VectorShuffle(vector, indexs);
+
+        /// <summary>
+        ///  uint8x16_t vshuf_b(uint8x16_t vec0, uint8x16_t vec1, uint8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<byte> VectorShuffle(Vector128<byte> vector0, Vector128<byte> vector1, Vector128<byte> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int8x16_t vshuf_b(int8x16_t vec0, int8x16_t vec1, int8x16_t idx)
+        ///   LSX: VSHUF.B Vd.16B, Vj.16B, Vk.16B, Va.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorShuffle(Vector128<sbyte> vector0, Vector128<sbyte> vector1, Vector128<sbyte> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int16x8_t vshuf_h(int16x8_t vec0, int16x8_t vec1, int16x8_t idx)
+        ///   LSX: VSHUF.H Vd.8H, Vj.8H, Vk.8H                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<short> VectorShuffle(Vector128<short> vector0, Vector128<short> vector1, Vector128<short> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint16x8_t vshuf_h(uint16x8_t vecj, uint16x8_t veck, uint16x8_t idx)
+        ///   LSX: VSHUF.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorShuffle(Vector128<ushort> vector0, Vector128<ushort> vector1, Vector128<ushort> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int32x4_t vpermi_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<int> VectorShuffle(Vector128<int> vector, const byte indexs) => VectorShuffle(vector, indexs);
+
+        /// <summary>
+        ///  uint32x4_t vpermi_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VPERMI.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector, const byte indexs) => VectorShuffle(vector, indexs);
+
+        /// <summary>
+        ///  int32x4_t vshuf_w(int32x4_t vec0, int32x4_t vec1, int32x4_t idx)
+        ///   LSX: VSHUF.W Vd.4W, Vj.4W, Vk.4W                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<int> VectorShuffle(Vector128<int> vector0, Vector128<int> vector1, Vector128<int> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint32x4_t vshuf_w(uint32x4_t vecj, uint32x4_t veck, uint32x4_t idx)
+        ///   LSX: VSHUF.W Vd.4W, Vj.4W, Vk.4W                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<uint> VectorShuffle(Vector128<uint> vector0, Vector128<uint> vector1, Vector128<uint> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int64x2_t vshuf_d(int64x2_t vec0, int64x2_t vec1, int64x2_t idx)
+        ///   LSX: VSHUF.D Vd.2D, Vj.2D, Vk.2D                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<long> VectorShuffle(Vector128<long> vector0, Vector128<long> vector1, Vector128<long> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint64x2_t vshuf_d(uint64x2_t vecj, uint64x2_t veck, uint64x2_t idx)
+        ///   LSX: VSHUF.D Vd.2D, Vj.2D, Vk.2D                                //NOTE: Vd is both input and output while input as index.
+        /// </summary>
+        public static Vector128<ulong> VectorShuffle(Vector128<ulong> vector0, Vector128<ulong> vector1, Vector128<ulong> indexs) => VectorShuffle(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int8x16_t vshuf4i_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<sbyte> VectorShuffleBy4Elements(Vector128<sbyte> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  uint8x16_t vshuf4i_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<byte> VectorShuffleBy4Elements(Vector128<byte> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  int16x8_t vshuf4i_h(int16x8_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<short> VectorShuffleBy4Elements(Vector128<short> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  uint16x8_t vshuf4i_h(uint16x8_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<ushort> VectorShuffleBy4Elements(Vector128<ushort> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  int32x4_t vshuf4i_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<int> VectorShuffleBy4Elements(Vector128<int> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  uint32x4_t vshuf4i_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VSHUF4I.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<uint> VectorShuffleBy4Elements(Vector128<uint> vector, byte indexs) => VectorShuffleBy4Elements(vector, indexs);
+
+        /// <summary>
+        ///  int64x2_t vshuf4i_d(int64x2_t vec0, uint64x2_t vec1, uint8_t idx)
+        ///   LSX: VSHUF4I.D Vd.2D, Vj.2D, ui4
+        /// </summary>
+        public static Vector128<long> VectorShuffleBy4Elements(Vector128<long> vector0, Vector128<long> vector1, byte indexs) => VectorShuffleBy4Elements(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  uint64x2_t vshuf4i_d(uint64x2_t vec0, uint64x2_t vec1, uint8_t idx)
+        ///   LSX: VSHUF4I.D Vd.2D, Vj.2D, ui4
+        /// </summary>
+        public static Vector128<ulong> VectorShuffleBy4Elements(Vector128<ulong> vector0, Vector128<ulong> vector1, byte indexs) => VectorShuffleBy4Elements(vector0, vector1, indexs);
+
+        /// <summary>
+        ///  int8x16_t vilvl_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VILVL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionLower(Vector128<sbyte> left, Vector128<sbyte> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vilvl_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VILVL.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionLower(Vector128<byte> left, Vector128<byte> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  int16x8_t vilvl_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VILVL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionLower(Vector128<short> left, Vector128<short> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  uint16x8_t vilvl_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VILVL.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionLower(Vector128<ushort> left, Vector128<ushort> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  int32x4_t vilvl_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VILVL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionLower(Vector128<int> left, Vector128<int> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  uint32x4_t vilvl_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VILVL.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionLower(Vector128<uint> left, Vector128<uint> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  int64x2_t vilvl_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VILVL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionLower(Vector128<long> left, Vector128<long> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  uint64x2_t vilvl_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VILVL.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionLower(Vector128<ulong> left, Vector128<ulong> right) => VectorElementsFusionLower(left, right);
+
+        /// <summary>
+        ///  int8x16_t vilvh_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VILVH.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionHight(Vector128<sbyte> left, Vector128<sbyte> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vilvh_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VILVH.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionHight(Vector128<byte> left, Vector128<byte> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  int16x8_t vilvh_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VILVH.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionHight(Vector128<short> left, Vector128<short> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  uint16x8_t vilvh_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VILVH.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionHight(Vector128<ushort> left, Vector128<ushort> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  int32x4_t vilvh_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VILVH.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionHight(Vector128<int> left, Vector128<int> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  uint32x4_t vilvh_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VILVH.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionHight(Vector128<uint> left, Vector128<uint> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  int64x2_t vilvh_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VILVH.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionHight(Vector128<long> left, Vector128<long> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  uint64x2_t vilvh_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VILVH.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionHight(Vector128<ulong> left, Vector128<ulong> right) => VectorElementsFusionHight(left, right);
+
+        /// <summary>
+        ///  int8x16_t vpackev_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPACKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionEven(Vector128<sbyte> left, Vector128<sbyte> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vpackev_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPACKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionEven(Vector128<byte> left, Vector128<byte> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int16x8_t vpackev_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPACKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionEven(Vector128<short> left, Vector128<short> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint16x8_t vpackev_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPACKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionEven(Vector128<ushort> left, Vector128<ushort> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int32x4_t vpackev_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPACKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionEven(Vector128<int> left, Vector128<int> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint32x4_t vpackev_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPACKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionEven(Vector128<uint> left, Vector128<uint> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int64x2_t vpackev_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPACKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionEven(Vector128<long> left, Vector128<long> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  uint64x2_t vpackev_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPACKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionEven(Vector128<ulong> left, Vector128<ulong> right) => VectorElementsFusionEven(left, right);
+
+        /// <summary>
+        ///  int8x16_t vpackod_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPACKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementsFusionOdd(Vector128<sbyte> left, Vector128<sbyte> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vpackod_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPACKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementsFusionOdd(Vector128<byte> left, Vector128<byte> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int16x8_t vpackod_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPACKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementsFusionOdd(Vector128<short> left, Vector128<short> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint16x8_t vpackod_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPACKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementsFusionOdd(Vector128<ushort> left, Vector128<ushort> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int32x4_t vpackod_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPACKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementsFusionOdd(Vector128<int> left, Vector128<int> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint32x4_t vpackod_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPACKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementsFusionOdd(Vector128<uint> left, Vector128<uint> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int64x2_t vpackod_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPACKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementsFusionOdd(Vector128<long> left, Vector128<long> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  uint64x2_t vpackod_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPACKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementsFusionOdd(Vector128<ulong> left, Vector128<ulong> right) => VectorElementsFusionOdd(left, right);
+
+        /// <summary>
+        ///  int8x16_t vpickev_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPICKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorEvenElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vpickev_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPICKEV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorEvenElementsJoin(Vector128<byte> left, Vector128<byte> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  int16x8_t vpickev_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPICKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorEvenElementsJoin(Vector128<short> left, Vector128<short> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint16x8_t vpickev_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPICKEV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorEvenElementsJoin(Vector128<ushort> left, Vector128<ushort> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  int32x4_t vpickev_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPICKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorEvenElementsJoin(Vector128<int> left, Vector128<int> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint32x4_t vpickev_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPICKEV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorEvenElementsJoin(Vector128<uint> left, Vector128<uint> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  int64x2_t vpickev_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPICKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorEvenElementsJoin(Vector128<long> left, Vector128<long> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint64x2_t vpickev_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPICKEV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorEvenElementsJoin(Vector128<ulong> left, Vector128<ulong> right) => VectorEvenElementsJoin(left, right);
+
+        /// <summary>
+        ///  int8x16_t vpickod_b(int8x16_t vec0, int8x16_t vec1)
+        ///   LSX: VPICKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorOddElementsJoin(Vector128<sbyte> left, Vector128<sbyte> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vpickod_b(uint8x16_t vec0, uint8x16_t vec1)
+        ///   LSX: VPICKOD.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorOddElementsJoin(Vector128<byte> left, Vector128<byte> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  int16x8_t vpickod_h(int16x8_t vec0, int16x8_t vec1)
+        ///   LSX: VPICKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorOddElementsJoin(Vector128<short> left, Vector128<short> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint16x8_t vpickod_h(uint16x8_t vec0, uint16x8_t vec1)
+        ///   LSX: VPICKOD.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorOddElementsJoin(Vector128<ushort> left, Vector128<ushort> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  int32x4_t vpickod_w(int32x4_t vec0, int32x4_t vec1)
+        ///   LSX: VPICKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorOddElementsJoin(Vector128<int> left, Vector128<int> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint32x4_t vpickod_w(uint32x4_t vec0, uint32x4_t vec1)
+        ///   LSX: VPICKOD.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorOddElementsJoin(Vector128<uint> left, Vector128<uint> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  int64x2_t vpickod_d(int64x2_t vec0, int64x2_t vec1)
+        ///   LSX: VPICKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorOddElementsJoin(Vector128<long> left, Vector128<long> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint64x2_t vpickod_d(uint64x2_t vec0, uint64x2_t vec1)
+        ///   LSX: VPICKOD.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorOddElementsJoin(Vector128<ulong> left, Vector128<ulong> right) => VectorOddElementsJoin(left, right);
+
+        /// <summary>
+        ///  uint8x16_t vreplve_b(uint8x16_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.B Vd.16B, Vj.16B, rk
+        ///   LSX: VREPLVEI.B Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<byte> VectorElementReplicate(Vector128<byte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int8x16_t vreplve_b(int8x16_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.B Vd.16B, Vj.16B, rk
+        ///   LSX: VREPLVEI.B Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> VectorElementReplicate(Vector128<sbyte> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int16x8_t vreplve_h(int16x8_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.H Vd.8H, Vj.8H, rk
+        ///   LSX: VREPLVEI.H Vd.8H, Vj.8H, ui3
+        /// </summary>
+        public static Vector128<short> VectorElementReplicate(Vector128<short> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint16x8_t vreplve_h(uint16x8_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.H Vd.8H, Vj.8H, rk
+        ///   LSX: VREPLVEI.H Vd.8H, Vj.8H, ui3
+        /// </summary>
+        public static Vector128<ushort> VectorElementReplicate(Vector128<ushort> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int32x4_t vreplve_w(int32x4_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.W Vd.4W, Vj.4W, rk
+        ///   LSX: VREPLVEI.W Vd.4W, Vj.4W, ui2
+        /// </summary>
+        public static Vector128<int> VectorElementReplicate(Vector128<int> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint32x4_t vreplve_w(uint32x4_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.W Vd.4W, Vj.4W, rk
+        ///   LSX: VREPLVEI.W Vd.4W, Vj.4W, ui2
+        /// </summary>
+        public static Vector128<uint> VectorElementReplicate(Vector128<uint> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int64x2_t vreplve_d(int64x2_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.D Vd.2D, Vj.2D, rk
+        ///   LSX: VREPLVEI.D Vd.2D, Vj.2D, ui1
+        /// </summary>
+        public static Vector128<long> VectorElementReplicate(Vector128<long> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  uint64x2_t vreplve_d(uint64x2_t vector, uint8_t idx)
+        ///   LSX: VREPLVE.D Vd.2D, Vj.2D, rk
+        ///   LSX: VREPLVEI.D Vd.2D, Vj.2D, ui1
+        /// </summary>
+        public static Vector128<ulong> VectorElementReplicate(Vector128<ulong> vector, byte elementIndexe) => VectorElementReplicate(vector, elementIndexe);
+
+        /// <summary>
+        ///  int8x16_t vextrins_b(int8x16_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<sbyte> UpdateOneVectorElement(Vector128<sbyte> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  uint8x16_t vextrins_b(uint8x16_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.B Vd.16B, Vj.16B, ui8
+        /// </summary>
+        public static Vector128<byte> UpdateOneVectorElement(Vector128<byte> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  int16x8_t vextrins_h(int16x8_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<short> UpdateOneVectorElement(Vector128<short> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  uint16x8_t vextrins_h(uint16x8_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.H Vd.8H, Vj.8H, ui8
+        /// </summary>
+        public static Vector128<ushort> UpdateOneVectorElement(Vector128<ushort> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  int32x4_t vextrins_w(int32x4_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<int> UpdateOneVectorElement(Vector128<int> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  uint32x4_t vextrins_w(uint32x4_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.W Vd.4W, Vj.4W, ui8
+        /// </summary>
+        public static Vector128<uint> UpdateOneVectorElement(Vector128<uint> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  int64x2_t vextrins_d(int64x2_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.D Vd.2D, Vj.2D, ui8
+        /// </summary>
+        public static Vector128<long> UpdateOneVectorElement(Vector128<long> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  uint64x2_t vextrins_d(uint64x2_t vec, uint8_t idx)
+        ///   LSX: VEXTRINS.D Vd.2D, Vj.2D, ui8
+        /// </summary>
+        public static Vector128<ulong> UpdateOneVectorElement(Vector128<ulong> vector, const byte indexs) => UpdateOneVectorElement(vector, indexs);
+
+        /// <summary>
+        ///  int8x16_t vsigncov_b(int8x16_t sign, int8x16_t data)
+        ///   LSX: VSIGNCOV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementNegatedBySign(Vector128<sbyte> sign, Vector128<sbyte> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        ///  int16x8_t vsigncov_h(int16x8_t sign, int16x8_t data)
+        ///   LSX: VSIGNCOV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementNegatedBySign(Vector128<short> sign, Vector128<short> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        ///  int32x4_t vsigncov_w(int32x4_t sign, int32x4_t data)
+        ///   LSX: VSIGNCOV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementNegatedBySign(Vector128<int> sign, Vector128<int> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        ///  int64x2_t vsigncov_d(int64x2_t sign, int64x2_t data)
+        ///   LSX: VSIGNCOV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementNegatedBySign(Vector128<long> sign, Vector128<long> data) => VectorElementNegatedBySign(sign, data);
+
+        /// <summary>
+        /// int8x16_t vbitclri_b(int8x16_t a, const int n)
+        ///   LSX: VBITCLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint8x16_t vbitclri_b(uint8x16_t a, const int n)
+        ///   LSX: VBITCLRI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int16x8_t vbitclri_h(int16x8_t a, const int n)
+        ///   LSX: VBITCLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorElementBitClear(Vector128<short> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint16x8_t vbitclri_h(uint16x8_t a, const int n)
+        ///   LSX: VBITCLRI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorElementBitClear(Vector128<int> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitclri_w(uint32x4_t a, const int n)
+        ///   LSX: VBITCLRI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int64x2_t vbitclri_d(int64x2_t a, const int n)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorElementBitClear(Vector128<long> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint64x2_t vbitclri_d(uint64x2_t a, const int n)
+        ///   LSX: VBITCLRI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, const byte index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int8x16_t vbitclr_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITCLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitClear(Vector128<sbyte> value, Vector128<sbyte> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint8x16_t vbitclr_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITCLR.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementBitClear(Vector128<byte> value, Vector128<byte> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int16x8_t vbitclr_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITCLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementBitClear(Vector128<short> value, Vector128<short> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint16x8_t vbitclr_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITCLR.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitClear(Vector128<ushort> value, Vector128<ushort> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int32x4_t vbitclr_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITCLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementBitClear(Vector128<int> value, Vector128<int> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitclr_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITCLR.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementBitClear(Vector128<uint> value, Vector128<uint> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int64x2_t vbitclr_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITCLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementBitClear(Vector128<long> value, Vector128<long> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// uint64x2_t vbitclr_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITCLR.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitClear(Vector128<ulong> value, Vector128<ulong> index) => VectorElementBitClear(value, index);
+
+        /// <summary>
+        /// int8x16_t vbitseti_b(int8x16_t a, const int n)
+        ///   LSX: VBITSETI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint8x16_t vbitseti_b(uint8x16_t a, const int n)
+        ///   LSX: VBITSETI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int16x8_t vbitseti_h(int16x8_t a, const int n)
+        ///   LSX: VBITSETI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorElementBitSet(Vector128<short> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint16x8_t vbitseti_h(uint16x8_t a, const int n)
+        ///   LSX: VBITSETI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorElementBitSet(Vector128<int> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitseti_w(uint32x4_t a, const int n)
+        ///   LSX: VBITSETI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int64x2_t vbitseti_d(int64x2_t a, const int n)
+        ///   LSX: VBITSETI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorElementBitSet(Vector128<long> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint64x2_t vbitseti_d(uint64x2_t a, const int n)
+        ///   LSX: VBITSETI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, const byte index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int8x16_t vbitset_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITSET.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitSet(Vector128<sbyte> value, Vector128<sbyte> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint8x16_t vbitset_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITSET.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementBitSet(Vector128<byte> value, Vector128<byte> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int16x8_t vbitset_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITSET.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementBitSet(Vector128<short> value, Vector128<short> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint16x8_t vbitset_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITSET.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitSet(Vector128<ushort> value, Vector128<ushort> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int32x4_t vbitset_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITSET.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementBitSet(Vector128<int> value, Vector128<int> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitset_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITSET.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementBitSet(Vector128<uint> value, Vector128<uint> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int64x2_t vbitset_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITSET.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementBitSet(Vector128<long> value, Vector128<long> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// uint64x2_t vbitset_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITSET.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitSet(Vector128<ulong> value, Vector128<ulong> index) => VectorElementBitSet(value, index);
+
+        /// <summary>
+        /// int8x16_t vbitrevi_b(int8x16_t a, const int n)
+        ///   LSX: VBITREVI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint8x16_t vbitrevi_b(uint8x16_t a, const int n)
+        ///   LSX: VBITREVI.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int16x8_t vbitrevi_h(int16x8_t a, const int n)
+        ///   LSX: VBITREVI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint16x8_t vbitrevi_h(uint16x8_t a, const int n)
+        ///   LSX: VBITREVI.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitrevi_w(uint32x4_t a, const int n)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitrevi_w(uint32x4_t a, const int n)
+        ///   LSX: VBITREVI.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int64x2_t vbitrevi_d(int64x2_t a, const int n)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint64x2_t vbitrevi_d(uint64x2_t a, const int n)
+        ///   LSX: VBITREVI.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, const byte index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int8x16_t vbitrev_b(int8x16_t a, int8x16_t b)
+        ///   LSX: VBITREV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> VectorElementBitRevert(Vector128<sbyte> value, Vector128<sbyte> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint8x16_t vbitrev_b(uint8x16_t a, uint8x16_t b)
+        ///   LSX: VBITREV.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<byte> VectorElementBitRevert(Vector128<byte> value, Vector128<byte> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int16x8_t vbitrev_h(int16x8_t value, int16x8_t index)
+        ///   LSX: VBITREV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> VectorElementBitRevert(Vector128<short> value, Vector128<short> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint16x8_t vbitrev_h(uint16x8_t value, uint16x8_t index)
+        ///   LSX: VBITREV.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<ushort> VectorElementBitRevert(Vector128<ushort> value, Vector128<ushort> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int32x4_t vbitrev_w(int32x4_t value, int32x4_t index)
+        ///   LSX: VBITREV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<int> VectorElementBitRevert(Vector128<int> value, Vector128<int> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint32x4_t vbitrev_w(uint32x4_t value, uint32x4_t index)
+        ///   LSX: VBITREV.W Vd.4W, Vj.4W, Vk.4W
+        /// </summary>
+        public static Vector128<uint> VectorElementBitRevert(Vector128<uint> value, Vector128<uint> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int64x2_t vbitrev_d(int64x2_t value, int64x2_t index)
+        ///   LSX: VBITREV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<long> VectorElementBitRevert(Vector128<long> value, Vector128<long> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// uint64x2_t vbitrev_d(uint64x2_t value, uint64x2_t index)
+        ///   LSX: VBITREV.D Vd.2D, Vj.2D, Vk.2D
+        /// </summary>
+        public static Vector128<ulong> VectorElementBitRevert(Vector128<ulong> value, Vector128<ulong> index) => VectorElementBitRevert(value, index);
+
+        /// <summary>
+        /// int8x16_t vfrstp_b(int8x16_t value, int8x16_t save)
+        ///   LSX: VFRSTP.B Vd.16B, Vj.16B, Vk.16B
+        /// </summary>
+        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, Vector128<sbyte> save) => IndexOfFirstNegativeElement(value, save);
+
+        /// <summary>
+        /// int16x8_t vfrstp_h(int16x8_t value, int16x8_t save)
+        ///   LSX: VFRSTP.H Vd.8H, Vj.8H, Vk.8H
+        /// </summary>
+        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, Vector128<short> save) => IndexOfFirstNegativeElement(value, save);
+
+        /// <summary>
+        /// int8x16_t vfrstpi_b(int8x16_t value, uint8_t save)
+        ///   LSX: VFRSTPI.B Vd.16B, Vj.16B, ui4
+        /// </summary>
+        public static Vector128<sbyte> IndexOfFirstNegativeElement(Vector128<sbyte> value, const byte save) => IndexOfFirstNegativeElement(value, save);
+
+        /// <summary>
+        /// int16x8_t vfrstpi_h(int16x8_t value, uint8_t save)
+        ///   LSX: VFRSTPI.H Vd.8H, Vj.8H, ui3
+        /// </summary>
+        public static Vector128<short> IndexOfFirstNegativeElement(Vector128<short> value, const byte save) => IndexOfFirstNegativeElement(value, save);
+
+        /// <summary>
+        /// int8x16_t vsat_b(int8x16_t value, uint8_t ui3)
+        ///   LSX: VSAT.B Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<sbyte> VectorSaturate(Vector128<sbyte> value, [ConstantExpected(Max = (byte)(7))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// int16x8_t vsat_h(int16x8_t value, uint8_t ui4)
+        ///   LSX: VSAT.H Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<short> VectorSaturate(Vector128<short> value, [ConstantExpected(Max = (byte)(15))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// int32x4_t vsat_w(int32x4_t value, uint8_t ui5)
+        ///   LSX: VSAT.W Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<int> VectorSaturate(Vector128<int> value, [ConstantExpected(Max = (byte)(31))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// int64x2_t vsat_d(int64x2_t value, uint8_t ui6)
+        ///   LSX: VSAT.D Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<long> VectorSaturate(Vector128<long> value, [ConstantExpected(Max = (byte)(63))] byte bits) => VectorSaturate(value, bits);
+
+        /// <summary>
+        /// uint8x16_t vsat_bu(uint8x16_t value, uint8_t ui3)
+        ///   LSX: VSAT.BU Vd.16B, Vj.16B, ui3
+        /// </summary>
+        public static Vector128<byte> VectorSaturateUnsigned(Vector128<byte> value, [ConstantExpected(Max = (byte)(7))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// uint16x8_t vsat_hu(uint16x8_t value, uint8_t ui4)
+        ///   LSX: VSAT.HU Vd.8H, Vj.8H, ui4
+        /// </summary>
+        public static Vector128<ushort> VectorSaturateUnsigned(Vector128<ushort> value, [ConstantExpected(Max = (byte)(15))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// uint32x4_t vsat_wu(uint32x4_t value, uint8_t ui5)
+        ///   LSX: VSAT.WU Vd.4W, Vj.4W, ui5
+        /// </summary>
+        public static Vector128<uint> VectorSaturateUnsigned(Vector128<uint> value, [ConstantExpected(Max = (byte)(31))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// uint64x2_t vsat_du(uint64x2_t value, uint8_t ui6)
+        ///   LSX: VSAT.DU Vd.2D, Vj.2D, ui6
+        /// </summary>
+        public static Vector128<ulong> VectorSaturateUnsigned(Vector128<ulong> value, [ConstantExpected(Max = (byte)(63))] byte bits) => VectorSaturateUnsigned(value, bits);
+
+        /// <summary>
+        /// int32x4_t vfclass_s(float32x4_t a)
+        ///   LSX: VFCLASS.S Vd.4S, Vj.4S
+        /// </summary>
+        public static Vector128<int> FloatClass(Vector128<float> value) => FloatClass(value);
+
+        /// <summary>
+        /// int64x2_t vfclass_d(float64x2_t a)
+        ///   LSX: VFCLASS.D Vd.2D, Vj.2D
+        /// </summary>
+        public static Vector128<long> FloatClass(Vector128<double> value) => FloatClass(value);
+    }
+}
diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
index e0f07a1441e248..c90a5828490008 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -3959,6 +3959,2019 @@ internal Arm64() { }
         }
     }
 }
+namespace System.Runtime.Intrinsics.LoongArch
+{
+    [System.CLSCompliantAttribute(false)]
+    public abstract partial class LoongArchBase
+    {
+        internal LoongArchBase() { }
+        public static bool IsSupported { get { throw null; } }
+
+        public abstract partial class LoongArch64
+        {
+            internal LoongArch64() { }
+            public static bool IsSupported { get { throw null; } }
+
+            public static int LeadingSignCount(int value) { throw null; }
+            public static int LeadingSignCount(uint value) { throw null; }
+            public static int LeadingSignCount(long value) { throw null; }
+            public static int LeadingSignCount(ulong value) { throw null; }
+            public static int LeadingZeroCount(int value) { throw null; }
+            public static int LeadingZeroCount(uint value) { throw null; }
+            public static int LeadingZeroCount(long value) { throw null; }
+            public static int LeadingZeroCount(ulong value) { throw null; }
+            public static int TrailingOneCount(int value) { throw null; }
+            public static int TrailingOneCount(uint value) { throw null; }
+            public static int TrailingOneCount(long value) { throw null; }
+            public static int TrailingOneCount(ulong value) { throw null; }
+            public static int TrailingZeroCount(int value) { throw null; }
+            public static int TrailingZeroCount(uint value) { throw null; }
+            public static int TrailingZeroCount(long value) { throw null; }
+            public static int TrailingZeroCount(ulong value) { throw null; }
+            public static long MultiplyHigh(long left, long right) { throw null; }
+            public static ulong MultiplyHigh(ulong left, ulong right) { throw null; }
+            public static long ReverseElementBits(long value) { throw null; }
+            public static ulong ReverseElementBits(ulong value) { throw null; }
+            public static long ReverseElementBits(int value) { throw null; }
+            public static ulong ReverseElementBits(uint value) { throw null; }
+            public static int ReverseElementBits(int value) { throw null; }
+            public static uint ReverseElementBits(uint value) { throw null; }
+            public static long ReverseElementBits(long value) { throw null; }
+            public static ulong ReverseElementBits(ulong value) { throw null; }
+            public static float ReciprocalEstimate(float value) { throw null; }
+            public static double ReciprocalEstimate(double value) { throw null; }
+            public static float ReciprocalSqrtEstimate(float value) { throw null; }
+            public static double ReciprocalSqrtEstimate(double value) { throw null; }
+            public static long CyclicRedundancyCheckIEEE8023(int crc, byte checks) { throw null; }
+            public static long CyclicRedundancyCheckIEEE8023(int crc, ushort checks) { throw null; }
+            public static long CyclicRedundancyCheckIEEE8023(int crc, uint checks) { throw null; }
+            public static long CyclicRedundancyCheckIEEE8023(int crc, ulong checks) { throw null; }
+            public static long CyclicRedundancyCheckCastagnoli(int crc, byte checks) { throw null; }
+            public static long CyclicRedundancyCheckCastagnoli(int crc, ushort checks) { throw null; }
+            public static long CyclicRedundancyCheckCastagnoli(int crc, uint checks) { throw null; }
+            public static long CyclicRedundancyCheckCastagnoli(int crc, ulong checks) { throw null; }
+        }
+
+        public static long MultiplyHigh(int left, int right) { throw null; }
+        public static ulong MultiplyHigh(uint left, uint right) { throw null; }
+        public static float SquareRoot(float value) { throw null; }
+        public static double SquareRoot(double value) { throw null; }
+        public static float Reciprocal(float value) { throw null; }
+        public static double Reciprocal(double value) { throw null; }
+        public static float ReciprocalSqrt(float value) { throw null; }
+        public static double ReciprocalSqrt(double value) { throw null; }
+        public static float FloatLogarithm2(float value) { throw null; }
+        public static double FloatLogarithm2(double value) { throw null; }
+        public static float FloatScaleBinary(float value, int index) { throw null; }
+        public static double FloatScaleBinary(double value, long index) { throw null; }
+        public static float FloatCopySign(float value, float sign) { throw null; }
+        public static double FloatCopySign(double value, double sign) { throw null; }
+        public static float FloatClass(float value) { throw null; }
+        public static double FloatClass(double value) { throw null; }
+    }
+    [System.CLSCompliantAttribute(false)]
+    public abstract partial class Lsx : System.Runtime.Intrinsics.LoongArch.LoongArchBase
+    {
+        internal Lsx() { }
+        public static new bool IsSupported { get { throw null; } }
+
+        public static System.Runtime.Intrinsics.Vector64<sbyte> Add(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> Add(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> Add(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> Add(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> Add(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> Add(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> Add(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> Add(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> Add(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> Add(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Add(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Add(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Add(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Add(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Add(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Add(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Add(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Add(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Add(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Add(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> AddSaturate(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> AddSaturate(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> AddSaturate(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> AddSaturate(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> AddSaturate(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> AddSaturate(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> AddSaturate(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> AddSaturate(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AddSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddSaturate(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> AddSaturate(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AddSaturate(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AddSaturate(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddSaturate(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> AddHorizontalElements(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> Subtract(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> Subtract(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> Subtract(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> Subtract(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> Subtract(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> Subtract(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> Subtract(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> Subtract(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> Subtract(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> Subtract(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Subtract(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Subtract(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Subtract(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Subtract(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> 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; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Subtract(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Subtract(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Subtract(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Subtract(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Subtract(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> SubtractSaturate(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> SubtractSaturate(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> SubtractSaturate(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> SubtractSaturate(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> SubtractSaturate(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> SubtractSaturate(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> SubtractSaturate(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> SubtractSaturate(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Multiply(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Multiply(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Multiply(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Multiply(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Multiply(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Multiply(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Multiply(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Multiply(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Multiply(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<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<sbyte> MultiplyHight(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> MultiplyHight(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyHight(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyHight(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyHight(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyHight(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyHight(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyHight(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Divide(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Divide(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Divide(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Divide(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Divide(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Divide(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Divide(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Divide(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> 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.Vector128<double> Divide(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Modulo(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Modulo(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Modulo(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Modulo(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Modulo(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Modulo(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Modulo(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Modulo(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, System.Runtime.Intrinsics.Vector128<float> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.Vector128<double> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplyAddNegated(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, System.Runtime.Intrinsics.Vector128<float> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplyAddNegated(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.Vector128<double> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> MultiplyAdd(System.Runtime.Intrinsics.Vector128<sbyte> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> MultiplyAdd(System.Runtime.Intrinsics.Vector128<byte> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyAdd(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyAdd(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, System.Runtime.Intrinsics.Vector128<float> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.Vector128<double> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> FusedMultiplySubtractNegated(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right, System.Runtime.Intrinsics.Vector128<float> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FusedMultiplySubtractNegated(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right, System.Runtime.Intrinsics.Vector128<double> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> MultiplySubtract(System.Runtime.Intrinsics.Vector128<sbyte> minuend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { 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<ushort> MultiplySubtract(System.Runtime.Intrinsics.Vector128<ushort> minuend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> 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; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplySubtract(System.Runtime.Intrinsics.Vector128<uint> minuend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplySubtract(System.Runtime.Intrinsics.Vector128<long> minuend, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplySubtract(System.Runtime.Intrinsics.Vector128<ulong> minuend, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<int> addend, System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningLowerAndAdd(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<ulong> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<short> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<ushort> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningUpperAndAdd(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<uint> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<uint> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningUpperAndAdd(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<ulong> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector128<ulong> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareNotEqualZero(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareNotEqualZero(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareEqual(System.Runtime.Intrinsics.Vector128<sbyte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareEqual(System.Runtime.Intrinsics.Vector128<short> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareEqual(System.Runtime.Intrinsics.Vector128<int> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareEqual(System.Runtime.Intrinsics.Vector128<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareEqual(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareEqual(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareEqual(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> CompareEqual(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareEqual(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> CompareEqual(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareEqual(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> CompareEqual(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareLessThanZero(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareLessThanZero(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThanZero(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThanZero(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareLessThan(System.Runtime.Intrinsics.Vector128<sbyte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareLessThan(System.Runtime.Intrinsics.Vector128<short> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThan(System.Runtime.Intrinsics.Vector128<int> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThan(System.Runtime.Intrinsics.Vector128<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareLessThan(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareLessThan(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareLessThan(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> CompareLessThan(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThan(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> CompareLessThan(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThan(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> CompareLessThan(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThan(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThan(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<sbyte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<short> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<int> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<byte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<ushort> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<uint> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareGreaterThan(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareGreaterThanOrEqualZero(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Max(System.Runtime.Intrinsics.Vector128<sbyte> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Max(System.Runtime.Intrinsics.Vector128<byte> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Max(System.Runtime.Intrinsics.Vector128<short> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Max(System.Runtime.Intrinsics.Vector128<ushort> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Max(System.Runtime.Intrinsics.Vector128<int> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Max(System.Runtime.Intrinsics.Vector128<uint> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Max(System.Runtime.Intrinsics.Vector128<long> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Max(System.Runtime.Intrinsics.Vector128<ulong> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Max(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Max(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Max(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Max(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Max(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Max(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Max(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Max(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Max(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Max(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> MaxFloatAbsolute(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> MaxFloatAbsolute(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Min(System.Runtime.Intrinsics.Vector128<sbyte> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Min(System.Runtime.Intrinsics.Vector128<byte> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Min(System.Runtime.Intrinsics.Vector128<short> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Min(System.Runtime.Intrinsics.Vector128<ushort> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Min(System.Runtime.Intrinsics.Vector128<int> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Min(System.Runtime.Intrinsics.Vector128<uint> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Min(System.Runtime.Intrinsics.Vector128<long> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Min(System.Runtime.Intrinsics.Vector128<ulong> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Min(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Min(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Min(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        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<int> Min(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> 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<long> Min(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Min(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Min(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Min(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> MinFloatAbsolute(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> MinFloatAbsolute(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> BitwiseSelect(System.Runtime.Intrinsics.Vector128<sbyte> select, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> BitwiseSelect(System.Runtime.Intrinsics.Vector128<byte> select, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> BitwiseSelect(System.Runtime.Intrinsics.Vector128<short> select, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> BitwiseSelect(System.Runtime.Intrinsics.Vector128<ushort> select, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> BitwiseSelect(System.Runtime.Intrinsics.Vector128<int> select, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> BitwiseSelect(System.Runtime.Intrinsics.Vector128<uint> select, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> BitwiseSelect(System.Runtime.Intrinsics.Vector128<long> select, System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> BitwiseSelect(System.Runtime.Intrinsics.Vector128<ulong> select, System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> BitwiseSelect(System.Runtime.Intrinsics.Vector128<float> select, System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> BitwiseSelect(System.Runtime.Intrinsics.Vector128<double> select, System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AbsoluteDifference(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<sbyte> LoadVector128(sbyte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<byte> LoadVector128(byte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<short> LoadVector128(short* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<ushort> LoadVector128(ushort* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<int> LoadVector128(int* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<uint> LoadVector128(uint* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<long> LoadVector128(long* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<ulong> LoadVector128(ulong* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<float> LoadVector128(float* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<double> LoadVector128(double* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<sbyte> LoadVector128(sbyte* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<byte> LoadVector128(byte* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<short> LoadVector128(short* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<ushort> LoadVector128(ushort* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<int> LoadVector128(int* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<uint> LoadVector128(uint* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<long> LoadVector128(long* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<ulong> LoadVector128(ulong* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<float> LoadVector128(float* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<double> LoadVector128(double* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<sbyte> LoadElementReplicateVector(sbyte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<byte> LoadElementReplicateVector(byte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<short> LoadElementReplicateVector(short* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<ushort> LoadElementReplicateVector(ushort* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<int> LoadElementReplicateVector(int* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<uint> LoadElementReplicateVector(uint* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<long> LoadElementReplicateVector(long* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<ulong> LoadElementReplicateVector(ulong* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<float> LoadElementReplicateVector(float* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector128<double> LoadElementReplicateVector(double* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Reciprocal(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Reciprocal(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> ReciprocalSqrt(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> ReciprocalSqrt(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.Vector128<double> Sqrt(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> FloatLogarithm2(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> FloatLogarithm2(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<sbyte> vector, sbyte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<byte> vector, byte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<short> vector, short* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<ushort> vector, ushort* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<int> vector, int* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<uint> vector, uint* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<long> vector, long* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<ulong> vector, ulong* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<float> vector, float* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector128<double> vector, double* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<sbyte> vector, sbyte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -128, Max = 127)] short si8, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<byte> vector, byte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -128, Max = 127)] short si8, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<short> vector, short* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -256, Max = 254)] short si9, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<ushort> vector, ushort* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -256, Max = 254)] short si9, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<int> vector, int* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -512, Max = 508)] short si10, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<uint> vector, uint* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -512, Max = 508)] short si10, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<long> vector, long* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -1024, Max = 1016)] short si11, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<ulong> vector, ulong* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -1024, Max = 1016)] short si11, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<float> vector, float* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -512, Max = 511)] short si10, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector128<double> vector, double* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -1024, Max = 1016)] short si11, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(1))] byte idx) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Negate(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Negate(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Negate(System.Runtime.Intrinsics.Vector128<int> 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<float> Negate(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Negate(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> NegateScalar(System.Runtime.Intrinsics.Vector64<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> NegateScalar(System.Runtime.Intrinsics.Vector64<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<ushort> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<byte> leftUnsign, System.Runtime.Intrinsics.Vector128<byte> rightUnsign) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<uint> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<ulong> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<short> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<byte> unsign, System.Runtime.Intrinsics.Vector128<sbyte> sign) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<int> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<ushort> unsign, System.Runtime.Intrinsics.Vector128<short> sign) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<uint> unsign, System.Runtime.Intrinsics.Vector128<int> sign) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector128<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector128<ulong> unsign, System.Runtime.Intrinsics.Vector128<long> sign) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Average(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Average(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Average(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Average(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Average(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Average(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Average(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Average(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> AverageRounded(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> AverageRounded(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AverageRounded(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AverageRounded(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AverageRounded(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AverageRounded(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AverageRounded(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AverageRounded(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> SignExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> SignExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> SignExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<int> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ZeroExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ZeroExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ZeroExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ZeroExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<uint> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ZeroExtendWideningLowerAndShiftLeft(System.Runtime.Intrinsics.Vector64<int> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector64<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> SignExtendWideningUpper(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ZeroExtendWideningUpper(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> And(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> And(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> And(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> And(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> And(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> And(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> And(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> And(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> And(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> And(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> AndNot(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> AndNot(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> AndNot(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> AndNot(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> AndNot(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> AndNot(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AndNot(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AndNot(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> AndNot(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> AndNot(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> Or(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> Or(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> Or(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> Or(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> Or(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> Or(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> Or(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> Or(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> Or(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> Or(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Or(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Or(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Or(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Or(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Or(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Or(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Or(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Or(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Or(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Or(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> Not(System.Runtime.Intrinsics.Vector64<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> Not(System.Runtime.Intrinsics.Vector64<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> Not(System.Runtime.Intrinsics.Vector64<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> Not(System.Runtime.Intrinsics.Vector64<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> Not(System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> Not(System.Runtime.Intrinsics.Vector64<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> Not(System.Runtime.Intrinsics.Vector64<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> Not(System.Runtime.Intrinsics.Vector64<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> Not(System.Runtime.Intrinsics.Vector64<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> Not(System.Runtime.Intrinsics.Vector64<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Not(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Not(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Not(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Not(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Not(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Not(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Not(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Not(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Not(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Not(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> NotOr(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> NotOr(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> NotOr(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> NotOr(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> NotOr(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> NotOr(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> NotOr(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> NotOr(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> NotOr(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> NotOr(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> OrNot(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> OrNot(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> OrNot(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> OrNot(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> OrNot(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> OrNot(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> OrNot(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> OrNot(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> OrNot(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> OrNot(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> OrNot(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> OrNot(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> OrNot(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> OrNot(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> OrNot(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> OrNot(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> OrNot(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> OrNot(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> OrNot(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> OrNot(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> Xor(System.Runtime.Intrinsics.Vector64<byte> left, System.Runtime.Intrinsics.Vector64<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<double> Xor(System.Runtime.Intrinsics.Vector64<double> left, System.Runtime.Intrinsics.Vector64<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> Xor(System.Runtime.Intrinsics.Vector64<short> left, System.Runtime.Intrinsics.Vector64<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> Xor(System.Runtime.Intrinsics.Vector64<int> left, System.Runtime.Intrinsics.Vector64<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> Xor(System.Runtime.Intrinsics.Vector64<long> left, System.Runtime.Intrinsics.Vector64<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> Xor(System.Runtime.Intrinsics.Vector64<sbyte> left, System.Runtime.Intrinsics.Vector64<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<float> Xor(System.Runtime.Intrinsics.Vector64<float> left, System.Runtime.Intrinsics.Vector64<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> Xor(System.Runtime.Intrinsics.Vector64<ushort> left, System.Runtime.Intrinsics.Vector64<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> Xor(System.Runtime.Intrinsics.Vector64<uint> left, System.Runtime.Intrinsics.Vector64<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> Xor(System.Runtime.Intrinsics.Vector64<ulong> left, System.Runtime.Intrinsics.Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Xor(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Xor(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Xor(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Xor(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Xor(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Xor(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Xor(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Xor(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Xor(System.Runtime.Intrinsics.Vector128<float> left, System.Runtime.Intrinsics.Vector128<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Xor(System.Runtime.Intrinsics.Vector128<double> left, System.Runtime.Intrinsics.Vector128<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogicalByByte(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogicalByByte(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalByByte(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalByByte(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingLower(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<ushort> ShiftRightLogicalRoundedNarrowingLower(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<int> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingLower(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<int> ShiftRightArithmeticRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> RotateRight(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> RotateRight(System.Runtime.Intrinsics.Vector128<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> RotateRight(System.Runtime.Intrinsics.Vector128<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> RotateRight(System.Runtime.Intrinsics.Vector128<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> RotateRight(System.Runtime.Intrinsics.Vector128<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> RotateRight(System.Runtime.Intrinsics.Vector128<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> RotateRight(System.Runtime.Intrinsics.Vector128<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> RotateRight(System.Runtime.Intrinsics.Vector128<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> RotateRight(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> RotateRight(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> RotateRight(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> RotateRight(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> RotateRight(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> RotateRight(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> RotateRight(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> RotateRight(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Abs(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        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<ulong> Abs(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Abs(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Abs(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> Floor(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Ceiling(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Ceiling(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> RoundToZero(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> RoundToZero(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> RoundToNegativeInfinity(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> RoundToNegativeInfinity(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> RoundToPositiveInfinity(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> RoundToPositiveInfinity(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> Insert(System.Runtime.Intrinsics.Vector128<sbyte> vector, sbyte data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> Insert(System.Runtime.Intrinsics.Vector128<byte> vector, byte data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> Insert(System.Runtime.Intrinsics.Vector128<short> vector, short data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> Insert(System.Runtime.Intrinsics.Vector128<ushort> vector, ushort data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> Insert(System.Runtime.Intrinsics.Vector128<int> vector, int data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> Insert(System.Runtime.Intrinsics.Vector128<uint> vector, uint data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> Insert(System.Runtime.Intrinsics.Vector128<long> vector, long data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> Insert(System.Runtime.Intrinsics.Vector128<ulong> vector, ulong data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> Insert(System.Runtime.Intrinsics.Vector128<float> vector, float data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> Insert(System.Runtime.Intrinsics.Vector128<double> vector, double data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> DuplicateToSystem.Runtime.Intrinsics.Vector128(sbyte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> DuplicateToSystem.Runtime.Intrinsics.Vector128(byte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> DuplicateToSystem.Runtime.Intrinsics.Vector128(short value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> DuplicateToSystem.Runtime.Intrinsics.Vector128(ushort value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> DuplicateToSystem.Runtime.Intrinsics.Vector128(int value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> DuplicateToSystem.Runtime.Intrinsics.Vector128(uint value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> DuplicateToSystem.Runtime.Intrinsics.Vector128(long value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> DuplicateToSystem.Runtime.Intrinsics.Vector128(ulong value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> DuplicateToSystem.Runtime.Intrinsics.Vector128(float value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> DuplicateToSystem.Runtime.Intrinsics.Vector128(double value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> ConvertToSingle(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<float> ConvertToSingle(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> ConvertToDouble(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<double> ConvertToDouble(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static byte FirstNegativeInteger(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static ushort FirstNegativeInteger(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static bool HasElementsNotZero(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static bool AllElementsIsZero(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingLower(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingSaturateLower(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<ushort> ShiftRightLogicalNarrowingSaturateLower(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<int> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(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<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticNarrowingSaturateLower(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<int> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(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<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLower(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<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(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<int> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(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<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(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<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(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<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> LeadingSignCount(System.Runtime.Intrinsics.Vector64<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> LeadingSignCount(System.Runtime.Intrinsics.Vector64<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<int> LeadingSignCount(System.Runtime.Intrinsics.Vector64<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> LeadingSignCount(System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> LeadingSignCount(System.Runtime.Intrinsics.Vector128<sbyte> 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<long> LeadingSignCount(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<byte> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<sbyte> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<short> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<short> 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<int> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<uint> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<long> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<ulong> LeadingZeroCount(System.Runtime.Intrinsics.Vector64<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> LeadingZeroCount(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> PopCount(System.Runtime.Intrinsics.Vector128<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> PopCount(System.Runtime.Intrinsics.Vector128<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> PopCount(System.Runtime.Intrinsics.Vector128<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> PopCount(System.Runtime.Intrinsics.Vector128<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> PopCount(System.Runtime.Intrinsics.Vector128<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> PopCount(System.Runtime.Intrinsics.Vector128<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> PopCount(System.Runtime.Intrinsics.Vector128<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> PopCount(System.Runtime.Intrinsics.Vector128<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorShuffle(System.Runtime.Intrinsics.Vector128<byte> vector, System.Runtime.Intrinsics.Vector128<byte> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorShuffle(System.Runtime.Intrinsics.Vector128<sbyte> vector, System.Runtime.Intrinsics.Vector128<sbyte> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorShuffle(System.Runtime.Intrinsics.Vector128<byte> vector0, System.Runtime.Intrinsics.Vector128<byte> vector1, System.Runtime.Intrinsics.Vector128<byte> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorShuffle(System.Runtime.Intrinsics.Vector128<sbyte> vector0, System.Runtime.Intrinsics.Vector128<sbyte> vector1, System.Runtime.Intrinsics.Vector128<sbyte> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorShuffle(System.Runtime.Intrinsics.Vector128<short> vector0, System.Runtime.Intrinsics.Vector128<short> vector1, System.Runtime.Intrinsics.Vector128<short> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorShuffle(System.Runtime.Intrinsics.Vector128<ushort> vector0, System.Runtime.Intrinsics.Vector128<ushort> vector1, System.Runtime.Intrinsics.Vector128<ushort> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorShuffle(System.Runtime.Intrinsics.Vector128<int> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorShuffle(System.Runtime.Intrinsics.Vector128<uint> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorShuffle(System.Runtime.Intrinsics.Vector128<int> vector0, System.Runtime.Intrinsics.Vector128<int> vector1, System.Runtime.Intrinsics.Vector128<int> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorShuffle(System.Runtime.Intrinsics.Vector128<uint> vector0, System.Runtime.Intrinsics.Vector128<uint> vector1, System.Runtime.Intrinsics.Vector128<uint> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorShuffle(System.Runtime.Intrinsics.Vector128<long> vector0, System.Runtime.Intrinsics.Vector128<long> vector1, System.Runtime.Intrinsics.Vector128<long> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorShuffle(System.Runtime.Intrinsics.Vector128<ulong> vector0, System.Runtime.Intrinsics.Vector128<ulong> vector1, System.Runtime.Intrinsics.Vector128<ulong> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<sbyte> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<byte> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<short> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<ushort> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<int> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<uint> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<long> vector0, System.Runtime.Intrinsics.Vector128<long> vector1, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector128<ulong> vector0, System.Runtime.Intrinsics.Vector128<ulong> vector1, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementsFusionLower(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementsFusionHight(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorEvenElementsJoin(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<long> left, System.Runtime.Intrinsics.Vector128<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorOddElementsJoin(System.Runtime.Intrinsics.Vector128<ulong> left, System.Runtime.Intrinsics.Vector128<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<byte> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<sbyte> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<short> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<ushort> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<int> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<uint> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<long> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementReplicate(System.Runtime.Intrinsics.Vector128<ulong> vector, byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<sbyte> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<byte> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<short> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<ushort> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<int> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<uint> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<long> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> UpdateOneVectorElement(System.Runtime.Intrinsics.Vector128<ulong> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementNegatedBySign(System.Runtime.Intrinsics.Vector128<sbyte> sign, System.Runtime.Intrinsics.Vector128<sbyte> data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementNegatedBySign(System.Runtime.Intrinsics.Vector128<short> sign, System.Runtime.Intrinsics.Vector128<short> data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementNegatedBySign(System.Runtime.Intrinsics.Vector128<int> sign, System.Runtime.Intrinsics.Vector128<int> data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementNegatedBySign(System.Runtime.Intrinsics.Vector128<long> sign, System.Runtime.Intrinsics.Vector128<long> data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<byte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<short> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<ushort> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<int> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<uint> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<long> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<ulong> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementBitClear(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<byte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<short> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<ushort> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<int> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<uint> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<long> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<ulong> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementBitSet(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<byte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<short> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<ushort> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<int> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<uint> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<long> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<ulong> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<byte> value, System.Runtime.Intrinsics.Vector128<byte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<ushort> value, System.Runtime.Intrinsics.Vector128<ushort> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<int> value, System.Runtime.Intrinsics.Vector128<int> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<uint> value, System.Runtime.Intrinsics.Vector128<uint> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<long> value, System.Runtime.Intrinsics.Vector128<long> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorElementBitRevert(System.Runtime.Intrinsics.Vector128<ulong> value, System.Runtime.Intrinsics.Vector128<ulong> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> IndexOfFirstNegativeElement(System.Runtime.Intrinsics.Vector128<sbyte> value, System.Runtime.Intrinsics.Vector128<sbyte> save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> IndexOfFirstNegativeElement(System.Runtime.Intrinsics.Vector128<short> value, System.Runtime.Intrinsics.Vector128<short> save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> IndexOfFirstNegativeElement(System.Runtime.Intrinsics.Vector128<sbyte> value, const byte save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> IndexOfFirstNegativeElement(System.Runtime.Intrinsics.Vector128<short> value, const byte save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> VectorSaturate(System.Runtime.Intrinsics.Vector128<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> VectorSaturate(System.Runtime.Intrinsics.Vector128<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> VectorSaturate(System.Runtime.Intrinsics.Vector128<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> VectorSaturate(System.Runtime.Intrinsics.Vector128<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector128<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector128<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector128<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector128<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> FloatClass(System.Runtime.Intrinsics.Vector128<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> FloatClass(System.Runtime.Intrinsics.Vector128<double> value) { throw null; }
+    }
+    [System.CLSCompliantAttribute(false)]
+    public abstract partial class Lasx : System.Runtime.Intrinsics.LoongArch.Lsx
+    {
+        internal Lasx() { }
+        public static new bool IsSupported { get { throw null; } }
+
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Add(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Add(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Add(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Add(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Add(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Add(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Add(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Add(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Add(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Add(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> 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<short> AddSaturate(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddSaturate(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AddSaturate(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> 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<uint> AddSaturate(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddSaturate(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AddOddElementsWidening(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<long> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ulong> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static Vector64<float> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static Vector64<double> AddHorizontalElements(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Subtract(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Subtract(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Subtract(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Subtract(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Subtract(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Subtract(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Subtract(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Subtract(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Subtract(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Subtract(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> SubtractOddEvenElementsWidening(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> SubtractSaturate(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> SubtractSaturate(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SubtractSaturate(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> SubtractSaturate(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SubtractSaturate(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> SubtractSaturate(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SubtractSaturate(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> SubtractSaturate(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Multiply(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Multiply(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Multiply(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Multiply(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Multiply(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Multiply(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Multiply(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Multiply(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        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> Multiply(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> MultiplyHight(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> MultiplyHight(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyHight(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyHight(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyHight(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyHight(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyHight(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyHight(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Divide(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Divide(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Divide(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Divide(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Divide(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Divide(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Divide(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Divide(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> 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<double> Divide(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Modulo(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Modulo(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Modulo(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Modulo(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Modulo(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Modulo(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Modulo(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Modulo(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, System.Runtime.Intrinsics.Vector256<float> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplyAdd(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, System.Runtime.Intrinsics.Vector256<double> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> FusedMultiplyAddNegated(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, System.Runtime.Intrinsics.Vector256<float> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplyAddNegated(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, System.Runtime.Intrinsics.Vector256<double> addend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> MultiplyAdd(System.Runtime.Intrinsics.Vector256<sbyte> addend, System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> MultiplyAdd(System.Runtime.Intrinsics.Vector256<byte> addend, System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyAdd(System.Runtime.Intrinsics.Vector256<short> addend, System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyAdd(System.Runtime.Intrinsics.Vector256<ushort> addend, System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyAdd(System.Runtime.Intrinsics.Vector256<int> addend, System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyAdd(System.Runtime.Intrinsics.Vector256<uint> addend, System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyAdd(System.Runtime.Intrinsics.Vector256<long> addend, System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyAdd(System.Runtime.Intrinsics.Vector256<ulong> addend, System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, System.Runtime.Intrinsics.Vector256<float> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplySubtract(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, System.Runtime.Intrinsics.Vector256<double> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> FusedMultiplySubtractNegated(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right, System.Runtime.Intrinsics.Vector256<float> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FusedMultiplySubtractNegated(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right, System.Runtime.Intrinsics.Vector256<double> minuend) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> MultiplySubtract(System.Runtime.Intrinsics.Vector256<sbyte> minuend, System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> MultiplySubtract(System.Runtime.Intrinsics.Vector256<byte> minuend, System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplySubtract(System.Runtime.Intrinsics.Vector256<short> minuend, System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplySubtract(System.Runtime.Intrinsics.Vector256<ushort> minuend, System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplySubtract(System.Runtime.Intrinsics.Vector256<int> minuend, System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplySubtract(System.Runtime.Intrinsics.Vector256<uint> minuend, System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplySubtract(System.Runtime.Intrinsics.Vector256<long> addend, System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplySubtract(System.Runtime.Intrinsics.Vector256<ulong> addend, System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector256<short> addend, System.Runtime.Intrinsics.Vector128<sbyte> left, System.Runtime.Intrinsics.Vector128<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector256<ushort> addend, System.Runtime.Intrinsics.Vector128<byte> left, System.Runtime.Intrinsics.Vector128<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector256<int> addend, System.Runtime.Intrinsics.Vector128<short> left, System.Runtime.Intrinsics.Vector128<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector256<uint> addend, System.Runtime.Intrinsics.Vector128<ushort> left, System.Runtime.Intrinsics.Vector128<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector256<long> addend, System.Runtime.Intrinsics.Vector128<int> left, System.Runtime.Intrinsics.Vector128<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningLowerAndAdd(System.Runtime.Intrinsics.Vector256<ulong> addend, System.Runtime.Intrinsics.Vector128<uint> left, System.Runtime.Intrinsics.Vector128<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector256<short> addend, System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector256<ushort> addend, System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector256<int> addend, System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector256<uint> addend, System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector256<long> addend, System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningUpperAndAdd(System.Runtime.Intrinsics.Vector256<ulong> addend, System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareNotEqualZeroEach128(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareNotEqualZeroEach128(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareEqual(System.Runtime.Intrinsics.Vector256<sbyte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareEqual(System.Runtime.Intrinsics.Vector256<short> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareEqual(System.Runtime.Intrinsics.Vector256<int> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareEqual(System.Runtime.Intrinsics.Vector256<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareEqual(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareEqual(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareEqual(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> CompareEqual(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareEqual(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> CompareEqual(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareEqual(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> CompareEqual(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> 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> CompareEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareLessThanZeroEach128(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareLessThanZeroEach128(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareLessThanZeroEach128(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareLessThanZeroEach128(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareLessThan(System.Runtime.Intrinsics.Vector256<sbyte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareLessThan(System.Runtime.Intrinsics.Vector256<short> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareLessThan(System.Runtime.Intrinsics.Vector256<int> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareLessThan(System.Runtime.Intrinsics.Vector256<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareLessThan(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareLessThan(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareLessThan(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> CompareLessThan(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareLessThan(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> CompareLessThan(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareLessThan(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> CompareLessThan(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> CompareLessThan(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> CompareLessThan(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<sbyte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<short> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<int> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<long> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -16, Max = (byte)(15))] sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<byte> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<ushort> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<uint> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<ulong> value,  [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareLessThanOrEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> CompareGreaterThan(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> CompareGreaterThan(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; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareGreaterThanOrEqualZeroEach128(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> CompareGreaterThanOrEqual(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Max(System.Runtime.Intrinsics.Vector256<sbyte> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Max(System.Runtime.Intrinsics.Vector256<byte> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Max(System.Runtime.Intrinsics.Vector256<short> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Max(System.Runtime.Intrinsics.Vector256<ushort> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Max(System.Runtime.Intrinsics.Vector256<int> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Max(System.Runtime.Intrinsics.Vector256<uint> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Max(System.Runtime.Intrinsics.Vector256<long> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Max(System.Runtime.Intrinsics.Vector256<ulong> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Max(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Max(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Max(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Max(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Max(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Max(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Max(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Max(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Max(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Max(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> MaxFloatAbsolute(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> MaxFloatAbsolute(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Min(System.Runtime.Intrinsics.Vector256<sbyte> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Min(System.Runtime.Intrinsics.Vector256<byte> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Min(System.Runtime.Intrinsics.Vector256<short> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Min(System.Runtime.Intrinsics.Vector256<ushort> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Min(System.Runtime.Intrinsics.Vector256<int> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Min(System.Runtime.Intrinsics.Vector256<uint> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Min(System.Runtime.Intrinsics.Vector256<long> value, const sbyte si5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Min(System.Runtime.Intrinsics.Vector256<ulong> value, const byte ui5) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Min(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Min(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Min(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Min(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Min(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Min(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Min(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Min(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Min(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Min(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> MinFloatAbsolute(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> MinFloatAbsolute(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> BitwiseSelect(System.Runtime.Intrinsics.Vector256<sbyte> select, System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> BitwiseSelect(System.Runtime.Intrinsics.Vector256<byte> select, System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> BitwiseSelect(System.Runtime.Intrinsics.Vector256<short> select, System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> BitwiseSelect(System.Runtime.Intrinsics.Vector256<ushort> select, System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> BitwiseSelect(System.Runtime.Intrinsics.Vector256<int> select, System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> BitwiseSelect(System.Runtime.Intrinsics.Vector256<uint> select, System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> BitwiseSelect(System.Runtime.Intrinsics.Vector256<long> select, System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> BitwiseSelect(System.Runtime.Intrinsics.Vector256<ulong> select, System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> BitwiseSelect(System.Runtime.Intrinsics.Vector256<float> select, System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> BitwiseSelect(System.Runtime.Intrinsics.Vector256<double> select, System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<float> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<double> AbsoluteDifference(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<sbyte> LoadVector256(sbyte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<byte> LoadVector256(byte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<short> LoadVector256(short* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<ushort> LoadVector256(ushort* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<int> LoadVector256(int* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<uint> LoadVector256(uint* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<long> LoadVector256(long* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<ulong> LoadVector256(ulong* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<float> LoadVector256(float* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<double> LoadVector256(double* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<sbyte> LoadVector256(sbyte* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<byte> LoadVector256(byte* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<short> LoadVector256(short* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<ushort> LoadVector256(ushort* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<int> LoadVector256(int* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<uint> LoadVector256(uint* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<long> LoadVector256(long* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<ulong> LoadVector256(ulong* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<float> LoadVector256(float* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<double> LoadVector256(double* address, long offsetValue) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<sbyte> LoadElementReplicateVector(sbyte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<byte> LoadElementReplicateVector(byte* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<short> LoadElementReplicateVector(short* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<ushort> LoadElementReplicateVector(ushort* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<int> LoadElementReplicateVector(int* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<uint> LoadElementReplicateVector(uint* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<long> LoadElementReplicateVector(long* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<ulong> LoadElementReplicateVector(ulong* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<float> LoadElementReplicateVector(float* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe System.Runtime.Intrinsics.Vector256<double> LoadElementReplicateVector(double* address, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Reciprocal(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Reciprocal(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> ReciprocalSqrt(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> ReciprocalSqrt(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 static System.Runtime.Intrinsics.Vector256<double> Sqrt(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> FloatLogarithm2(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> FloatLogarithm2(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<sbyte> vector, sbyte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<byte> vector, byte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<short> vector, short* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<ushort> vector, ushort* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<int> vector, int* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<uint> vector, uint* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<long> vector, long* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<ulong> vector, ulong* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<float> vector, float* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<double> vector, double* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -2048, Max = 2047)] short si12) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<sbyte> vector, sbyte* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<byte> vector, byte* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<short> vector, short* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<ushort> vector, ushort* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<int> vector, int* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<uint> vector, uint* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<long> vector, long* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<ulong> vector, ulong* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<float> vector, float* addr, long offsetValue) { throw null; }
+        public static unsafe void Store(System.Runtime.Intrinsics.Vector256<double> vector, double* addr, long offsetValue) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<sbyte> vector, sbyte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -128, Max = 127)] short si8, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<byte> vector, byte* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -128, Max = 127)] short si8, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<short> vector, short* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -256, Max = 254)] short si9, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<ushort> vector, ushort* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -256, Max = 254)] short si9, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<int> vector, int* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -512, Max = 508)] short si10, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<uint> vector, uint* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -512, Max = 508)] short si10, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte idx) { throw null; }
+ const      /// void xvstelm_d(int64x4_t val, int64_t* addr, const short si11, const byte idx) // Note: si11 is 8byte aligned.
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<long> vector, long* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -1024, Max = 1016)] short si11, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<ulong> vector, ulong* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -1024, Max = 1016)] short si11, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<float> vector, float* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -512, Max = 511)] short si10, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte idx) { throw null; }
+        public static unsafe void StoreElement(System.Runtime.Intrinsics.Vector256<double> vector, double* addr, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Min = -1024, Max = 1016)] short si11, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(3))] byte idx) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Negate(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Negate(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Negate(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Negate(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Negate(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Negate(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningOdd(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<short> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<int> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        // public static System.Runtime.Intrinsics.Vector256<long> MultiplyWideningEven(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Average(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> 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<short> Average(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> 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.Vector256<int> Average(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Average(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Average(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Average(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> AverageRounded(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AverageRounded(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AverageRounded(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AverageRounded(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AverageRounded(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AverageRounded(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AverageRounded(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> AverageRounded(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<int> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<uint> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ZeroExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ZeroExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ZeroExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ZeroExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<uint> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningLowerAndShiftLeftEach128(System.Runtime.Intrinsics.Vector256<int> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningLowerEach128(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLower(Vector64<sbyte> value, byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLower(Vector64<byte> value, byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(Vector64<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(Vector64<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(Vector64<short> value, byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(Vector64<ushort> value, byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<int> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningLower(System.Runtime.Intrinsics.Vector128<uint> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ZeroExtendWideningLower(Vector64<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningLower(Vector64<byte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningLower(Vector64<sbyte> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningLower(Vector64<ushort> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningLower(Vector64<short> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<uint> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningLower(System.Runtime.Intrinsics.Vector128<int> value, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> SignExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> SignExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> SignExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ZeroExtendWideningUpperEach128(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> And(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { 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<ushort> And(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> 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; }
+        public static System.Runtime.Intrinsics.Vector256<uint> And(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> And(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> And(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        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> And(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> AndNot(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> AndNot(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> AndNot(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> AndNot(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> AndNot(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> AndNot(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> AndNot(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        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<float> AndNot(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<sbyte> Or(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Or(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Or(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Or(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Or(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Or(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Or(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Or(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> 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.Vector256<double> Or(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Not(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Not(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Not(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Not(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Not(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Not(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Not(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Not(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Not(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Not(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> NotOr(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> NotOr(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> NotOr(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> NotOr(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> NotOr(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> NotOr(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> NotOr(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> NotOr(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> NotOr(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> NotOr(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right) { throw null; }
+        public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right) { throw null; }
+        public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right) { throw null; }
+        public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right) { throw null; }
+        public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right) { throw null; }
+        public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right) { throw null; }
+        public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right) { throw null; }
+        public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right) { throw null; }
+        public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right) { throw null; }
+        public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> OrNot(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> OrNot(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> OrNot(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> OrNot(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> OrNot(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> OrNot(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> OrNot(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> OrNot(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> OrNot(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> OrNot(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> Xor(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Xor(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> Xor(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Xor(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Xor(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Xor(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Xor(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Xor(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Xor(System.Runtime.Intrinsics.Vector256<float> left, System.Runtime.Intrinsics.Vector256<float> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Xor(System.Runtime.Intrinsics.Vector256<double> left, System.Runtime.Intrinsics.Vector256<double> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogicalByByteEach128(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftLeftLogicalByByteEach128(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftLeftLogical(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalByByteEach128(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalByByteEach128(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogical(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalRounded(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmetic(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticRounded(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> RotateRight(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> RotateRight(System.Runtime.Intrinsics.Vector256<byte> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> RotateRight(System.Runtime.Intrinsics.Vector256<short> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> RotateRight(System.Runtime.Intrinsics.Vector256<ushort> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> RotateRight(System.Runtime.Intrinsics.Vector256<int> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> RotateRight(System.Runtime.Intrinsics.Vector256<uint> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> RotateRight(System.Runtime.Intrinsics.Vector256<long> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> RotateRight(System.Runtime.Intrinsics.Vector256<ulong> value, const byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> RotateRight(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> RotateRight(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> RotateRight(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> RotateRight(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> RotateRight(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> RotateRight(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> RotateRight(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> RotateRight(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> Abs(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> Abs(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Abs(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Abs(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Abs(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Abs(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> Floor(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.Vector256<double> Ceiling(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> RoundToZero(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> RoundToNegativeInfinity(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> RoundToNegativeInfinity(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> RoundToPositiveInfinity(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> RoundToPositiveInfinity(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> Insert(System.Runtime.Intrinsics.Vector256<int> vector, int data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> Insert(System.Runtime.Intrinsics.Vector256<uint> vector, uint data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> Insert(System.Runtime.Intrinsics.Vector256<long> vector, long data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> Insert(System.Runtime.Intrinsics.Vector256<ulong> vector, ulong data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> Insert(System.Runtime.Intrinsics.Vector256<float> vector, float data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> Insert(System.Runtime.Intrinsics.Vector256<double> vector, double data, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> DuplicateToSystem.Runtime.Intrinsics.Vector256(sbyte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> DuplicateToSystem.Runtime.Intrinsics.Vector256(byte value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> DuplicateToSystem.Runtime.Intrinsics.Vector256(short value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> DuplicateToSystem.Runtime.Intrinsics.Vector256(ushort value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> DuplicateToSystem.Runtime.Intrinsics.Vector256(int value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> DuplicateToSystem.Runtime.Intrinsics.Vector256(uint value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> DuplicateToSystem.Runtime.Intrinsics.Vector256(long value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> DuplicateToSystem.Runtime.Intrinsics.Vector256(ulong value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> DuplicateToSystem.Runtime.Intrinsics.Vector256(float value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> DuplicateToSystem.Runtime.Intrinsics.Vector256(double value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> ConvertToSingle(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<float> ConvertToSingle(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> ConvertToDouble(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<double> ConvertToDouble(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static bool HasElementsNotZero(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static bool AllElementsIsZero(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static bool AllElementsNotZero(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static bool HasElementsIsZero(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ulonglong> left, System.Runtime.Intrinsics.Vector256<ulonglong> right, byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ulonglong> left, System.Runtime.Intrinsics.Vector256<ulonglong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ulonglong> left, System.Runtime.Intrinsics.Vector256<ulonglong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<long> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte shift) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<ulong> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<longlong> left, System.Runtime.Intrinsics.Vector256<longlong> right, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(127))] byte shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLowerEach128(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> shift) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> LeadingSignCount(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> LeadingSignCount(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> LeadingSignCount(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> LeadingSignCount(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> LeadingZeroCount(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> PopCount(System.Runtime.Intrinsics.Vector256<sbyte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> PopCount(System.Runtime.Intrinsics.Vector256<byte> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> PopCount(System.Runtime.Intrinsics.Vector256<short> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> PopCount(System.Runtime.Intrinsics.Vector256<ushort> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> PopCount(System.Runtime.Intrinsics.Vector256<int> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> PopCount(System.Runtime.Intrinsics.Vector256<uint> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> PopCount(System.Runtime.Intrinsics.Vector256<long> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> PopCount(System.Runtime.Intrinsics.Vector256<ulong> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorShuffle(System.Runtime.Intrinsics.Vector256<int> vector, System.Runtime.Intrinsics.Vector256<int> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorShuffle(System.Runtime.Intrinsics.Vector256<uint> vector, System.Runtime.Intrinsics.Vector256<uint> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorShuffle(System.Runtime.Intrinsics.Vector256<long> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorShuffle(System.Runtime.Intrinsics.Vector256<ulong> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorShuffle(System.Runtime.Intrinsics.Vector256<long> vector0, System.Runtime.Intrinsics.Vector256<long> vector1, const byte indexs) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<byte> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<byte> vector, System.Runtime.Intrinsics.Vector256<byte> indexs) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<sbyte> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<sbyte> vector, System.Runtime.Intrinsics.Vector256<sbyte> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<byte> vector0, System.Runtime.Intrinsics.Vector256<byte> vector1, System.Runtime.Intrinsics.Vector256<byte> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<sbyte> vector0, System.Runtime.Intrinsics.Vector256<sbyte> vector1, System.Runtime.Intrinsics.Vector256<sbyte> indexs) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<short> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<short> vector, System.Runtime.Intrinsics.Vector256<short> indexs) { throw null; }
+        //public static System.Runtime.Intrinsics.Vector256<ushort> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<ushort> vector, System.Runtime.Intrinsics.Vector256<ushort> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<short> vector0, System.Runtime.Intrinsics.Vector256<short> vector1, System.Runtime.Intrinsics.Vector256<short> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<ushort> vector0, System.Runtime.Intrinsics.Vector256<ushort> vector1, System.Runtime.Intrinsics.Vector256<ushort> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<int> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<uint> vector, const byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<int> vector0, System.Runtime.Intrinsics.Vector256<int> vector1, System.Runtime.Intrinsics.Vector256<int> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<uint> vector0, System.Runtime.Intrinsics.Vector256<uint> vector1, System.Runtime.Intrinsics.Vector256<uint> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<long> vector0, System.Runtime.Intrinsics.Vector256<long> vector1, System.Runtime.Intrinsics.Vector256<long> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorShuffleEach128(System.Runtime.Intrinsics.Vector256<ulong> vector0, System.Runtime.Intrinsics.Vector256<ulong> vector1, System.Runtime.Intrinsics.Vector256<ulong> indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<sbyte> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<byte> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<short> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<ushort> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<int> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<uint> vector, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<long> vector0, System.Runtime.Intrinsics.Vector256<long> vector1, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorShuffleBy4Elements(System.Runtime.Intrinsics.Vector256<ulong> vector0, System.Runtime.Intrinsics.Vector256<ulong> vector1, byte indexs) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementsFusionLowerEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementsFusionHightEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementsFusionEven(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementsFusionOdd(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorEvenElementsJoinEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<sbyte> left, System.Runtime.Intrinsics.Vector256<sbyte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<byte> left, System.Runtime.Intrinsics.Vector256<byte> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<short> left, System.Runtime.Intrinsics.Vector256<short> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<ushort> left, System.Runtime.Intrinsics.Vector256<ushort> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<int> left, System.Runtime.Intrinsics.Vector256<int> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<uint> left, System.Runtime.Intrinsics.Vector256<uint> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<long> left, System.Runtime.Intrinsics.Vector256<long> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorOddElementsJoinEach128(System.Runtime.Intrinsics.Vector256<ulong> left, System.Runtime.Intrinsics.Vector256<ulong> right) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<byte> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<sbyte> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<short> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<ushort> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<int> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<uint> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<long> vector, const byte elementIndexe) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementReplicateEach128(System.Runtime.Intrinsics.Vector256<ulong> vector, const byte elementIndexe) { throw null; }
+        public static Vector258<sbyte> UpdateOneVectorElementEach128(Vector258<sbyte> vector, const byte indexs) { throw null; }
+        public static Vector258<byte> UpdateOneVectorElementEach128(Vector258<byte> vector, const byte indexs) { throw null; }
+        public static Vector258<short> UpdateOneVectorElementEach128(Vector258<short> vector, const byte indexs) { throw null; }
+        public static Vector258<ushort> UpdateOneVectorElementEach128(Vector258<ushort> vector, const byte indexs) { throw null; }
+        public static Vector258<int> UpdateOneVectorElementEach128(Vector258<int> vector, const byte indexs) { throw null; }
+        public static Vector258<uint> UpdateOneVectorElementEach128(Vector258<uint> vector, const byte indexs) { throw null; }
+        public static Vector258<long> UpdateOneVectorElementEach128(Vector258<long> vector, const byte indexs) { throw null; }
+        public static Vector258<ulong> UpdateOneVectorElementEach128(Vector258<ulong> vector, const byte indexs) { throw null; }
+        public static Vector258<sbyte> VectorElementNegatedBySign(Vector258<sbyte> sign, Vector258<sbyte> data) { throw null; }
+        public static Vector258<short> VectorElementNegatedBySign(Vector258<short> sign, Vector258<short> data) { throw null; }
+        public static Vector258<int> VectorElementNegatedBySign(Vector258<int> sign, Vector258<int> data) { throw null; }
+        public static Vector258<long> VectorElementNegatedBySign(Vector258<long> sign, Vector258<long> data) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<byte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<short> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<ushort> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<int> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<uint> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<long> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<ulong> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementBitClear(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<byte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<short> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<ushort> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<int> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<uint> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<long> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<ulong> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementBitSet(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<byte> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<short> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<ushort> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<int> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<uint> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<long> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<ulong> value, const byte index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<byte> value, System.Runtime.Intrinsics.Vector256<byte> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<ushort> value, System.Runtime.Intrinsics.Vector256<ushort> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<int> value, System.Runtime.Intrinsics.Vector256<int> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<uint> value, System.Runtime.Intrinsics.Vector256<uint> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<long> value, System.Runtime.Intrinsics.Vector256<long> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorElementBitRevert(System.Runtime.Intrinsics.Vector256<ulong> value, System.Runtime.Intrinsics.Vector256<ulong> index) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> IndexOfFirstNegativeElementEach128(System.Runtime.Intrinsics.Vector256<sbyte> value, System.Runtime.Intrinsics.Vector256<sbyte> save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> IndexOfFirstNegativeElementEach128(System.Runtime.Intrinsics.Vector256<short> value, System.Runtime.Intrinsics.Vector256<short> save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> IndexOfFirstNegativeElementEach128(System.Runtime.Intrinsics.Vector256<sbyte> value, const byte save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> IndexOfFirstNegativeElementEach128(System.Runtime.Intrinsics.Vector256<short> value, const byte save) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<sbyte> VectorSaturate(System.Runtime.Intrinsics.Vector256<sbyte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<short> VectorSaturate(System.Runtime.Intrinsics.Vector256<short> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> VectorSaturate(System.Runtime.Intrinsics.Vector256<int> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> VectorSaturate(System.Runtime.Intrinsics.Vector256<long> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<byte> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector256<byte> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(7))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ushort> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector256<ushort> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(15))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<uint> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector256<uint> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(31))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<ulong> VectorSaturateUnsigned(System.Runtime.Intrinsics.Vector256<ulong> value, [System.Diagnostics.CodeAnalysis.ConstantExpectedAttribute(Max = (byte)(63))] byte bits) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<int> FloatClass(System.Runtime.Intrinsics.Vector256<float> value) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<long> FloatClass(System.Runtime.Intrinsics.Vector256<double> value) { throw null; }
+    }
+}
 namespace System.Runtime.Intrinsics.X86
 {
     [System.CLSCompliantAttribute(false)]